echo '{some json}' | tr -d '\n\t' | tr -s ' '

find . | grep -E "(/__pycache__$|\.pyc$|\.pyo$)" | tee >(xargs rm -rf)

import numpy as np
a = [0,1,2,3,4,5,6,7,8,9]

r = np.zeros((len(a),len(a)))
for x in a:
    for y in a:
        if y<x:
            continue # we skip y!
        r[x,y] = x+y

print(r)

[[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.]
 [ 0.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
 [ 0.  0.  4.  5.  6.  7.  8.  9. 10. 11.]
 [ 0.  0.  0.  6.  7.  8.  9. 10. 11. 12.]
 [ 0.  0.  0.  0.  8.  9. 10. 11. 12. 13.]
 [ 0.  0.  0.  0.  0. 10. 11. 12. 13. 14.]
 [ 0.  0.  0.  0.  0.  0. 12. 13. 14. 15.]
 [ 0.  0.  0.  0.  0.  0.  0. 14. 15. 16.]
 [ 0.  0.  0.  0.  0.  0.  0.  0. 16. 17.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.  0. 18.]]

def chunks(lst, n):
    """Yield successive n-sized chunks from lst.
    The last chunk may be smaller."""
    for i in range(0, len(lst), n):
        yield lst[i:i + n]

print(list(chunks(range(1, 9), 3)))

[range(1, 4), range(4, 7), range(7, 9)]

s = [x for xs in s for x in xs]

from collections import Counter
products = ["Apple", "Orange", "Banana", "Pear", "Apple", "Banana"]
element_counts = Counter(products)
print(element_counts)

Counter({'Apple': 2, 'Banana': 2, 'Orange': 1, 'Pear': 1})

def find_shard_id(SHARDS, value):
    # Flatten the ranges into a list of tuples (start, end, shard_id)
    ranges = [(start, end, shard_id) for shard_id, ranges_list in SHARDS.items() for start, end in ranges_list]

    # Sort the ranges by their start values
    ranges.sort(key=lambda x: x[0])

    # Perform a binary search on the sorted list
    left, right = 0, len(ranges) - 1
    while left <= right:
        mid = (left + right) // 2
        if ranges[mid][0] <= value <= ranges[mid][1]:
            return ranges[mid][2]
        elif value < ranges[mid][0]:
            right = mid - 1
        else:
            left = mid + 1

    # If no matching range is found, return None
    return None

SHARDS = {
    1: ((1, 10), (31, 40)),
    2: ((11, 20), (41, 50)),
    3: ((21, 30), (51, 60))
}

print(find_shard_id(SHARDS, 25))  # Output: 3
print(find_shard_id(SHARDS, 7))  # Output: 1
print(find_shard_id(SHARDS, 61))  # Output: None

3
1
None

import time

start_time = time.time()
time.sleep(2)
end_time = time.time()

print(f"Command executed in {end_time - start_time:.2f} seconds")

Command executed in 2.00 seconds

import logging
import sys

def lprint(*args) -> str:
    msg = ' '.join(map(str, args))
    return msg.strip()

# ------ main -------
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
logger.addHandler(handler)

logger.debug(lprint([1,23], 'sd'))
logger.setLevel(logging.INFO)
logger.debug(lprint([1,23], 'sd'))

[1, 23] sd
[1, 23] sd
[1, 23] sd
[1, 23] sd
[1, 23] sd
[1, 23] sd

from itertools import groupby

# Sample list of dictionaries
list_of_dicts = [
    {'host': 'A', 'other_key': 'value1'},
    {'host': 'B', 'other_key': 'value2'},
    {'host': 'A', 'other_key': 'value3'},
    {'host': 'C', 'other_key': 'value4'},
    {'host': 'B', 'other_key': 'value5'},
]
sorted_list = sorted(list_of_dicts, key=lambda x: x['host'])

# Group the sorted list by the 'host' key
for host, group in groupby(sorted_list, key=lambda x: x['host']):
    print(f"Host: {host} {list(group)}")

Host: A [{'host': 'A', 'other_key': 'value1'}, {'host': 'A', 'other_key': 'value3'}]
Host: B [{'host': 'B', 'other_key': 'value2'}, {'host': 'B', 'other_key': 'value5'}]
Host: C [{'host': 'C', 'other_key': 'value4'}]

import sys
sys.path.insert(0, '../src/')

• Bottle
• CherryPy
• Django
• Falcon
• FastAPI
• Flask
• Hug
• Pyramid
• Tornado
• web2py

• aiohttp
• Asyncio
• httpx
• Pillow
• Pygame
• PyGTK
• PyQT
• Requests
• Six
• Tkinter
• Twisted
• Kivy
• wxPython
• Scrapy

• Gensim
• MXNet
• NLTK
• Theano

• AWS
• Rackspace
• Linode
• OpenShift
• PythonAnywhere
• Heroku
• Microsoft Azure
• DigitalOcean
• Google Cloud Platform
• OpenStack

• No database development
• Tortoise ORM
• Dejavu
• Peewee
• SQLAlchemy
• Django ORM
• PonyORM
• Raw SQL
• SQLObject

• None
• Apache Samza
• Apache Kafka
• Dask
• Apache Beam
• Apache Hive
• Apache Hadoop/MapReduce
• Apache Spark
• Apache Tez
• Apache Flink
• ClickHouse

• CruiseControl
• Gitlab CI
• Travis CI
• TeamCity
• Bitbucket Pipelines
• AppVeyor
• GitHub Actions
• Jenkins / Hudson
• CircleCI
• Bamboo

• None
• Chef
• Puppet
• Custom solution
• Ansible
• Salt

• I don’t use any documentation tools
• Sphinx and furo - Sphinx theme (example https://github.com/simplistix/testfixtures)
• MKDocs
• Doxygen

• use Version Control Systems use Version Control Systems: Often use Version Control Systems: From timeto time use Version Control Systems: Never orAlmost never
• use Issue Trackers use Issue Trackers: Often use Issue Trackers: From timeto time use Issue Trackers: Never orAlmost never
• use code coverage use code coverage: Often use code coverage: From timeto time use code coverage: Never orAlmost never
• use code linting (programs that analyze code for potential errors) use code linting (programs that analyze code for potential errors): Often use code linting (programs that analyze code for potential errors): From timeto time use code linting (programs that analyze code for potential errors): Never orAlmost never
• use Continuous Integration tools use Continuous Integration tools: Often use Continuous Integration tools: From timeto time use Continuous Integration tools: Never orAlmost never
• use optional type hinting use optional type hinting: Often use optional type hinting: From timeto time use optional type hinting: Never orAlmost never
• use NoSQL databases use NoSQL databases: Often use NoSQL databases: From timeto time use NoSQL databases: Never orAlmost never
• use autocompletion in your editor use autocompletion in your editor: Often use autocompletion in your editor: From timeto time use autocompletion in your editor: Never orAlmost never
• run / debug or edit code on remote machines (remote hosts, VMs, etc.) run / debug or edit code on remote machines (remote hosts, VMs, etc.): Often run / debug or edit code on remote machines (remote hosts, VMs, etc.): From timeto time run / debug or edit code on remote machines (remote hosts, VMs, etc.): Never orAlmost never
• use SQL databases use SQL databases : Often use SQL databases : From timeto time use SQL databases : Never orAlmost never
• use a Python profiler use a Python profiler: Often use a Python profiler: From timeto time use a Python profiler: Never orAlmost never
• use Python virtual environments for your projects use Python virtual environments for your projects: Often use Python virtual environments for your projects: From timeto time use Python virtual environments for your projects: Never orAlmost never
• use a debugger use a debugger: Often use a debugger: From timeto time use a debugger: Never orAlmost never
• write tests for your code write tests for your code: Often write tests for your code: From timeto time write tests for your code: Never orAlmost never
• refactor your code refactor your code: Often refactor your code: From timeto time refactor your code: Never orAlmost never

• virtualenv
• venv
• virtualenvwrapper
• hatch
• Poetry
• pipenv
• Conda

• pip
• Conda
• pipenv
• Poetry
• venv (standard library)
• virtualenv
• flit
• tox
• PDM
• twine
• Containers (eg: via Docker)
• Virtual machines
• Workplace specific proprietary solution

• None
• pipenv
• poetry
• pip-tools

• None
• Dependabot
• PyUp
• Custom tools, e.g. a cron job or scheduled CI task
• No, my application dependencies are updated manually

• None
• pip
• easy_install
• Conda
• Poetry
• pip-sync
• pipx

• None / I'm not sure
• Setuptools
• build
• Wheel
• Enscons
• pex
• Flit
• Poetry
• conda-build
• maturin
• PDM-PEP517

• Architect
• QA engineer
• Business analyst
• DBA
• CIO / CEO / CTO
• Technical support
• Technical writer
• Team lead
• Systems analyst
• Data analyst
• Product manager
• Developer / Programmer

1. visit https://www.python.org/downloads/
2. apt install gpg
3. gpg –recv-keys 64E628F8D684696D
4. cd usr/local/src
5. wget https://www.python.org/ftp/python/3.11.9/Python-3.11.9.tar.xz
6. wget https://www.python.org/ftp/python/3.11.9/Python-3.11.9.tar.xz.asc
7. gpg –verify Python-3.11.9.tar.xz.asc
8. tar xpf Python-3.11.9.tar.xz
9. apt-get install apt install libbz2-dev libffi-dev libssl-dev zlib1g-dev?
10. cat README.rst
    • ./configure –with-zlib –with-openssl
    • make && make install
11. useradd –home=/home/hug –create-home –shell /bin/bash –user-group hug
12. sudo -u hub bash
13. pip install …

no module named zlib

apt-get install zlib-dev

pip is configured with locations that require TLS/SSL, however the ssl module in Python is not available

apt-get install apt install libbz2-dev libffi-dev libssl-dev
./configure && make && make install

update-alternatives –install /usr/bin/python python /usr/bin/python3.8 1 echo 1 | update-alternatives –config python

• interpreted
• code readability
• indentation instead of curly braces
• designed to be highly extensible
• garbage collector
• functions are first class citizens
• multiple inheritance
• all parameters (arguments) are passed by reference
• nothing in Python makes it possible to enforce data hiding
• all classes inherit from object

Multi-paradigm:

• imperative
• procedural
• object-oriented
• functional (in the Lisp tradition) - (itertools and functools) - borrowed from Haskell and Standard ML
• reflective
• aspect-oriented programming by metaprogramming[42] and metaobjects (magic methods)
• dynamic name resolution (late binding) ?????????

Typing discipline:

• Duck
• dynamic
• gradual (since 3.5) - mey be defined with type(static) or not(dynamic).
• strong

Python and CPython are managed by the non-profit Python Software Foundation.

The Python Standard Library 3.6

• string processing (regular expressions, Unicode, calculating differences between files)
• Internet protocols (HTTP, FTP, SMTP, XML-RPC, POP, IMAP, CGI programming)
• software engineering (unit testing, logging, profiling, parsing Python code)
• operating system interfaces (system calls, filesystems, TCP/IP sockets)

document Zen of Python (PEP 20)

• Beautiful is better than ugly
• Explicit is better than implicit
• Simple is better than complex
• Complex is better than complicated
• Readability counts
• Errors should never pass silently. Unless explicitly silenced.
• There should be one– and preferably only one –obvious way to do it.
• 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!

Other

• "there should be one—and preferably only one—obvious way to do it"
• goal - keeping it fun to use ( spam and eggs instead of the standard foo and bar)
• pythonic - related to style (code is pythonic )
• Pythonists, Pythonistas, and Pythoneers - питонутые

https://peps.python.org/pep-0020/#id3

Every revision of Python enjoys performance improvements over the previous version.

• 1989
• 2000 - Python 2.0 - cycle-detecting garbage collector and support for Unicode
• 2008 - Python 3.0 - not completely backward-compatible - include the 2to3 utility, which automates (at least partially) the translation of Python 2 code to Python 3.
• 2009 Python 3.1 ordered dictionaries,
• 2015 Python 3.5 typed varibles
• 2016 Python 3.6 asyncio, Formatted string literals (f-strings), Syntax for variable annotations.
  • PEP523 API to make frame evaluation pluggable at the C level.

3.7

• built-in breakpoint() function that calls pdb. before was: import pdb; pdb.set_trace()
• @dataclass - class annotations shugar
• contextvars module - mechanism for managing Thread-local context variables, similar to thread-local storage (TLS), PEP 550
• from dataclasses import dataclass @dataclass - comes with basic functionality already implemented: instantiate, print, and compare data class instances

3.8

• Positional-Only Parameter: pow(x, y, z=None, /)
• Assignment Expressions: if (match := pattern.search(data)) is not None: - This feature allows developers to assign values to variables within an expression.
• f"{a=}", f"Square has area of {(area := length**2)} perimeter of {(perimeter := length*4)}"
• new SyntaxWarnings: when to choose is over ==, miss a comma in a list

3.9

• Merge (|) and update (|=) added to dict library to compliment dict.update() method and {**d1, **d2}.
• Added str.removeprefix(prefix) and str.removesuffix(suffix) to easily remove unneeded sections of a string.
• More Flexible Decorators: Traditionally, a decorator has had to be a named, callable object, usually a function or a class. PEP 614 allows decorators to be any callable expression.
  • before: decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
  • after: decorator: '@' namedexpr_test NEWLINE
• typehints: list[int] do not require import typing;
• Annotated[int, ctype("char")] - integer that should be considered as a char type in C.
• Better time zones handling.
• The new parser based on PEG was introduced, making it easier to add new syntax to the language.

3.10

• Structural pattern matching (PEP 634) was added, providing a way to match against and destructure data structures.
  • match command.split(): case [action, obj]: # interpret action, obj
• The new Parenthesized context managers syntax (PEP 618) was introduced, making it easier to write context managers using less boilerplate code.
• Improved error messages and error recovery were added to the parser, making it easier to debug syntax errors.
• Parenthesized Context Managers: This feature improves the readability of with statements by allowing developers to use parentheses. with (open("test_file1.txt", "w") as test, open("test_file2.txt", "w") as test2):

3.11

• The built-in pip package installer was upgraded to version 21.0, providing new features and improvements to package management.
• Improved error messages and error handling were added to the interpreter, making it easier to understand and recover from runtime errors.
• Some of the built-in modules were updated and improved, including the asyncio and typing modules.
• Better hash randomization: This improves the security of Python by making it more difficult for attackers to exploit hash-based algorithms that are used for various operations such as dictionary lookups.
• package has been deprecated

3.12

• distutils removed
• allow perf - linux profiler, new API for profilers, sys.monitoring
• buffer protocol - access to the raw region of memory
• type-hits:
  • TypedDict - source of types. for typing **kwargs
  • doesn't need to import TypeVar. func[T] syntax to indicate generic type references
  • @override decorator can be used to flag methods that override methods in a parent

• concurrency preparing:

  • Immortal objects - to implement other optimizations (like avoiding copy-on-write)
  • subinterpreters - the ability to have multiple instances of an interpreter, each with its own GIL, no

  end-user interface to subinterpreters.

  • asyncio is larger and faster
• sqlite3 module: command-line interface has been added to the
• unittest: Add a –durations command line option, showing the N slowest test cases

3.13

• Just-In-Time (JIT) Compiler - translates specialized bytecode into machine code at runtime
• Free-Threaded Mode - disables the Global Interpreter Lock (GIL)
• random in CLI

CPython, the reference implementation of Python

• interpreter and a compiler as it compiles Python code into bytecode before interpreting it
• (GIL) problem - only one thread may be processing Python bytecode at any one time
  • One thread may be waiting for a client to reply, and another may be waiting for a database query to execute, while the third thread is actually processing Python code.
  • Concurrency can only be achieved with separate CPython interpreter processes managed by a multitasking operating system

implementations that are known to be compatible with a given version of the language are IronPython, Jython and PyPy.

• IronPython -C#- use JIT- targeting the .NET Framework and Mono. created here known not to work under CPython
• PyPy - just-in-time compiler. written completely in Python.
• Jython - Python in Java for the Java platform

CPython based:

• Cython - translates a Python script into C and makes direct C-level API calls into the Python interpreter

Stackless Python - a significant fork of CPython that implements microthreads; it does not use the C memory stack, thus allowing massively concurrent programs.

Numba - NumPy-aware optimizing runtime compiler for Python

MicroPython - Python for microcontrollers (runs on the pyboard and the BBC Microbit)

Jython and IronPython - do not have a GIL and so multithreaded execution for a CPU-bound python application will work. These platforms are always playing catch-up with new language features or library features, so unfortunately

Pythran, a static Python-to-C++ extension compiler for a subset of the language, mostly targeted at numerical computation. Pythran can be (and is probably best) used as an additional backend for NumPy code in Cython.

mypyc, a static Python-to-C extension compiler, based on the mypy static Python analyser. Like Cython's pure Python mode, mypyc can make use of PEP-484 type annotations to optimise code for static types. Cons: no support for low-level optimisations and typing, opinionated Python type interpretation, reduced Python compatibility and introspection after compilation

Nuitka, a static Python-to-C extension compiler.

• Pros: highly language compliant, reasonable performance gains, support for static application linking (similar to cython_freeze but with the ability to bundle library dependencies into a self-contained executable)
• Cons: no support for low-level optimisations and typing

Brython is an implementation of Python 3 for client-side web programming (in JavaScript). It provides a subset of Python 3 standard library combined with access to DOM objects. It is packaged in Gentoo as dev-python/brython.

• Java is compiled into bytecode and then executed by the JVM.
• C language is compiled into object code, and then becomes the executable file after the linker
• Python is first converted to the bytecode and then executed via ceval.c. The interpreter directly executes thetranslated instruction set.

Bytecide is a set of instructions for a virtual machine which is called the Python Virtual Machine (PVM).

The PVM is an interpreter that runs the bytecode.

The bytecode is platform-independent, but PVM is specific to the target machine. .pyc file.

The bytecode files are stored in a folder named pycache. This folder is automatically created when you try to import another file that you created.

manually create it: manually create it: python -m compileall file_1.py … file_n.py

binding the name to the object - x = 2 - (generic) name x receives a reference to a separate, dynamically allocated object of numeric (int) type of value 2

Количество отступов не важно.

if True: print "Answer" // both prints called suite and header line with : - if print "True" else: print "Answer" print "False"

Blank Lines - ignored

semicolon ( ; ) allows multiple statements

Внутри:

• INDENT - token означающий начало нового блока
• DEDENT - конец блока.

• арифметика произвольной точности длина чисел ограничена только объёмом доступной памяти
• Extensive mathematics library, and the third-party library NumPy that further extends the native capabilities
• a < b < c - support

• calling convention for web servers to forward requests to web applications or frameworks written in the Python programming language.
• like Java's "servlet" API.
• WSGI middleware components, which implement both sides of the API, typically in Python code.

• Context managers - object for with with __enter_₍₎, __exit_₍₎ or __aenter_₍₎ and __aexit_₍₎ methods.
• while else - else clause is only executed when your while condition becomes false. If you break out of the loop, or if an exception is raised, it won't be executed.

• https://docs.python.org/3.9/library/inspect.html
• https://docs.python.org/3/library/functions.html?highlight=__file__
• https://docs.python.org/3/reference/import.html
• https://geek-university.com/python/display-module-content/

__name__ - equal to 'main' when as a script or "python -m" or from an interactive prompt. 'main' is the name of the scope in which top-level code executes.

if name == "main": - not execute when imported

__file__ - full path to module file

import sys

print 'Number of arguments:', len(sys.argv), 'arguments.' print 'Argument List:', str(sys.argv)

getopt module for better

• -c cmd : program passed in as string (terminates option list)
• -m mod : run library module as a script (terminates option list)
• -O : remove assert and debug-dependent statements; add .opt-1 before .pyc extension; also PYTHONOPTIMIZE=x
• -OO : do -O changes and also discard docstrings; add .opt-2 before .pyc extension
• -s : don't add user site directory to sys.path; also PYTHONNOUSERSITE. Disable home/u2.local/lib/python3.8/site-packages
• -S : don't imply 'import site' on initialization
  • /usr/lib/python38.zip
  • /usr/lib/python3.8
  • /usr/lib/python3.8/lib-dynload

script_dir=os.path.dirname(os.path.abspath(file))

sys.path - Initialized from the environment variable PYTHONPATH, plus an installation-dependent default.

find module:

• import imp
• imp.find_module('numpy')

• dist-packages is a Debian-specific convention that is also present in its derivatives, like Ubuntu. Modules are installed to dist-packages when they come from the Debian package manager. This is to reduce conflict between the system Python, and any from-source Python build you might install manually.

https://wiki.debian.org/Python

os.stat(pf).st_size
os.stat(pf).st_mtime

os.environ - dictionary

try … except KeyError: - no variable in dictionary

os.environ.get('FLASK_SOMESTAFF') - None if no key

if

export BBB ; python
os.environ['BBB'] # KeyError

DEBUG = os.environ.get('DEBUG', False) # sed DEBUG to  True of False

https://peps.python.org/pep-0338/

• __name__ is always 'main'

https://docs.python.org/3/reference/datamodel.html

• None - a single value
• NotImplemented - Numeric methods and rich comparison methods should return this value if they do not implement the operation for the operands provided.
• Ellipsis - accessed through the literal … or the built-in name Ellipsis.
• numbers.Number
• Sequences - represent finite ordered sets indexed by non-negative numbers (len() for sequence)
  • mutable: lists, Byte Arrays
  • immutable: str, tuple, bytes
• Set types -
  • Sets - mutable
  • Frozen sets - frozenset()
• Mappings - indexet by [2:3], have del and
• Callable
  • Instance methods
  • Generator functions - function or method which uses the yield statement
    • when called, always returns an iterator object
  • Coroutine functions - async def - when called, returns a coroutine object
  • Asynchronous generator functions
  • Built-in functions
  • Built-in methods
  • Classes - factories for new instances of themselves
  • Class Instances - can be made callable by defining a __call_₍₎ method in their class.
• Modules name The module’s name, doc, file - The pathname of the file from which the module was loaded,__annotations__, dict is the module’s namespace as a dictionary object.
• Custom classes -
• Class instances

• everything is an object, even classes. (Von Neumann’s model of a “stored program computer”)
• object has identity, a type and a value
• identity - address in memory, never changed once created instance
  • id(object) = identity
  • x is y - compare identities x is not y
• type or class
  • type()
• value of some objects can change - mutable immutable - even if refered object inside mutable
  • numbers, strings and tuples are immutable
  • dictionaries and lists are mutable

• None - name to access single object - to signify the absence of a value = false.
• NotImplemented - name to access single object - Numeric methods and rich comparison methods should return this value if they do not implement the operation for the operands provided. = true.
• Ellipsis - single object with name to access - … or Ellipsis = true
• numbers.Number - immutable
  • numbers.Integral
    • Integers (int) - unlimited range
    • Booleans (bool) - 0 and 1, in most contextes "False" or "True"
  • numbers.Real (float) - underlying machine architecture определеяет accepted range and handling of overflow
  • numbers.Complex (complex) - z.real and z.imag - pair of machine-level double precision floating point numbers
• Sequences - finite ordered sets len() - index a[i]: 0 to n-1; min(s), max(s) ; s * n - n copies of s ; s + t concatenation; x in s - True if an item of s is equal to x
  • Immutable sequences - list.index(obj)
    • str - UTF-8 - s[0] = string with length 1(code point). ord(s) - code point to 0 - 10FFFF ; chr(i) int to integer.; str.encode() -> bytes.decode() <-
    • Tuple - неизменяемый (), (1,) (1,'23') any type.
    • range()
    • Bytes - items are 8-bit byte = 1-255 - literal xb'ab' ; bytes() - creates;
  • Mutable unhashable - del list[0] - без первого -
    • List - изменяемый [1,'3'] any type.
    • Byte Array - bytearray - bytearray()
    • memoryview
• Set types - unordered - finite sets of unique - immutable - compare by == ; has len()
  • set - mutable - items must be imutable x in set for x in set - {'h', 'o', 'l', 'e'}
  • frozenset - immutable and hashable - it can be used again as an element of another set
• Mappings - finite sets, finctions: del a[k], len()
  • Dictionary - mutable - Keys are unique within a dictionary - indexed by nearly arbitrary values -_Keys must be immutable_ - {2 : 'Zara', 'Age' : 7, 'Class' : 'First'} dict[3] = "my" # Add new entry
• Callable types - to which call operation can be applied - код, который можеть быть вызван
  • User-defined functions
  • Instance methods: read-only attributes:
  • Generator functions - function which returns a generator iterator. It looks like a normal function except that it contains yield expressions ??????
  • Coroutine functions - async def - returns a coroutine object ???
  • Asynchronous generator functions
  • Built-in functions - len() and math.sin() (math is a standard built-in module)
  • Built-in methods alist.append()
  • Classes - act as factories for new instances of themselves. arguments of the call are passed to __new_₍₎
  • Class Instances - may be callable by defining a __call_₍₎ method
• Modules
• Custom classes

• https://docs.python.org/3/library/stdtypes.html

false:

• None and False.
• zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• empty sequences and collections: '', (), [], {}, set(), range(0)

• import copy
• copy.copy(x) Return a shallow copy of x.
• copy.deepcopy(x[, memo]) Return a deep copy of x.
• calss own copy: __copy_₍₎ and __deepcopy_₍₎

Hash function used to address value by a key.

There is tradeoff what should be brokern: hash function that will not mirror changed of mutable object or dict and set that will not allow not hashable objects.

Solutions:

• freeze mutable to imutable, ex. list to typle

Set:

• bucket_index = self._hash(element) % self.size
• sets are resized when the load factor (the ratio of the number of elements to the number of buckets) exceeds a certain threshold.

To allow set to use other hash function hash function of kept object should be modified or whole Set class should be reimplemented.

• Replaceas “hash” with “hashlib”
• Chaining: When two different elements hash to the same bucket (a collision), Python uses chaining to store these elements in a linked list within that bucket.
• Open Addressing: Python also uses open addressing techniques to handle collisions, where the next available slot is used to store the element.
• performance monitoring

• https://docs.python.org/3/reference/datamodel.html
• https://docs.python.org/3/library/stdtypes.html
• object by name or by link: muttable immutalbe 2019 https://realpython.com/pointers-in-python/

data models, validation, serialization, UI

v: Annotated[T, *x]

• v: a “name” (variable, function parameter, . . . )
• T: a valid type
• x: at least one metadata (or annotation), passed in a variadic way. The metadata can be used for either static analysis or at runtime.

Ignorable: When a tool or a library does not support annotations or encounters an unknown annotation it should just ignore it and treat annotated type as the underlying type.

stored in obj.__annotations__

def function_name(parameter1: type) -> return_type:

from typing import Dict

def get_first_name(full_name: str) -> str:
    return full_name.split(" ")[0]

fallback_name: Dict[str, str] = {
    "first_name": "UserFirstName",
    "last_name": "UserLastName"
}

raw_name: str = input("Please enter your name: ")
first_name: str = get_first_name(raw_name)

# If the user didn't type anything in, use the fallback name
if not first_name:
    first_name = get_first_name(fallback_name)

print(f"Hi, {first_name}!")

• “str” is a built-in type.
• “string” is a module in the Python Standard Library. For providing constants and classes that aid in string manipulation. Constants: string.ascii_letters, string.digits, string.punctuation, etc.

S = 'str'; S = "str"; S = '''str''';

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up."""

• https://peps.python.org/pep-0498/
• https://docs.python.org/3/library/string.html#formatstrings

equivalent to format()

• '!s' calls str() on the expression
• '!r' calls repr() on the expression
• '!a' calls ascii() on the expression.

>>> name = "Fred"
>>> f"He said his name is {name!r}." # repr() is equivalent to !r
"He said his name is 'Fred'."

Символов после запятой

>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f"result: {value:{width}.{precision}}"  # nested fields
'result:      12.35'

Форматирование даты:

>>> today = datetime(year=2017, month=1, day=27)
>>> f"{today:%B %d, %Y}"  # using date format specifier
'January 27, 2017'
>>> number = 1024
>>> f"{number:#0x}"  # using integer format specifier
'0x400'

format:

>>> '{:,}'.format(1234567890)
'1,234,567,890'
>>> 'Correct answers: {:.2%}'.format(19/22)
'Correct answers: 86.36%'

• print ("My name is %s and weight is %d kg!" % ('Zara', 21))

• https://www.python.org/dev/peps/pep-0414/

str or strings - immutable sequences of Unicode code points.

r' R' raw strings

Raw strings do not treat the backslash as a special character at all. print (r'C:\\nowhere')

b' B' bytes (NOT str)

may only contain ASCII characters

(no term)

::

• r'string' - treat backslashes as literal characters
• f'string' or F'string' - f"He said his name is {name!r}." - formatted

• concatination at runtime

#Fastest:
s= ''.join([`num` for num in xrange(loop_count)])

def g():
    sb = []
    for i in range(30):
        sb.append("abcdefg"[i%7])

    return ''.join(sb)

print g()   # abcdefgabcdefgabcdefgabcdefgab

b''

• byte string tp unicode : str.decode()
• unicode to byte string: str.encode('')

Your string is already encoded with some encoding. Before encoding it to ascii, you must decode it first. Python is implicity trying to decode it (That's why you get a UnicodeDecodeError not UnicodeEncodeError).

class MyClass:
        a=None
c = MyClass()
c.a = 3 # instance

class MyClass:
    """MyClass.i and MyClass.f are valid attribute references"""
    i = 12345 # class value
    def __init__(self, a):
        self.i = a # create new object value
    def f(self):
        print("f")

x = MyClass(2) # instance ERROR!
x.a = 3; # data attibute

print(x.a)
print(x.i)
print(MyClass.i)
print(x.f)
print(MyClass.f)
# MyClass.f and x.f — it is a method object, not a function object.

3
2
12345
<bound method MyClass.f of <__main__.MyClass object at 0x7f37165d4790>>
<function MyClass.f at 0x7f37165c5440>

class Dog:
    kind = 'canine'         # class variable shared by all instances
    tricks = []             # static!

    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

#-------------- class method
: class C:
:    @classmethod
:    def f(cls, arg1, arg2, ...): ...
#May be called for class C.f() or for instance C().f() For derived class
#                  derived class object is passed as the implied first argument.

class A:
    c = 0
    def meth(self):
        self.c = 3
a = A()
a.meth()
print(A.c, a.c)

0 3
None

• instance.__class__ - The class to which a class instance belongs.
• class.__mro__ or mro() - This attribute is a tuple of classes that are considered when looking for base classes during method resolution.
• class.__subclasses_₍₎ - Each class keeps a list of weak references to its immediate subclasses.

Class -name The class name.

• __module__ The name of the module in which the class was defined.
• __dict__ The dictionary containing the class’s namespace.
• __bases__ A tuple containing the base classes, in the order of their occurrence in the base class list.
• __doc__ The class’s documentation string, or None if undefined.
• __annotations__ A dictionary containing variable annotations collected during class body execution. For best practices on working with annotations, please see Annotations Best Practices.
• __new__(cls,…) - static method - special-cased so you need not declare it as such. The return value of __new_₍₎ should be the new object instance (usually an instance of cls).
  • typically: super().__new__{(cls[, …])} with appropriate arguments and then modifying the newly-created instance as necessary before returning it.
  • then the new instance’s __init_₍₎ method will be invoked
• __call__(self,…)

Class instances

• super() - Return a proxy object that delegates method calls to a parent or sibling class of type

• no private variables

@property - pythonic way

class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature

    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32

    def get_temperature(self):
        print("Getting value")
        return self._temperature

    def set_temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self._temperature = value

    temperature = property(get_temperature,set_temperature)

>>> c.temperature
Getting value
0
>>> c.temperature = 37
Setting value


#----------- OR ------
class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature

    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32

    @property
    def temperature(self):
        print("Getting value")
        return self._temperature

    @temperature.setter
    def temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self._temperature = value

inheritance for shared behavior, not for polymorphism

class Square(object):
    def draw(self, canvas): pass

class Circle(object):
    def draw(self, canvas): pass

shapes = [Square(), Circle()]
for shape in shapes:
    shape.draw('canvas')

• https://docs.python.org/3/reference/datamodel.html

Это переопределение скрытых методов, которые позволяют использовать класс в конструкциях.

• public - all
• Protected: _property
• Provate: __property

object() or object - base for all clases

dir(object())

['class', 'delattr', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'gt', 'hash', 'init', 'init_subclass', 'le', 'lt', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'setattr', 'sizeof', 'str', 'subclasshook']

• __dict__ − Dictionary containing the class's namespace.
• __doc__ - docstring
• __init__ - constructor
• __str__ - toString() - Return a string version of object
• __name_ - Class name
• __module__ - Module name in which the class is defined. This attribute is "main" in interactive mode.
• __bases__ − A possibly empty tuple containing the base classes, in the order of their occurrence in the base class list.
• __hash__' - hashcode()
• __repr__ - string printable representation of an object

• simple
• отложенный
• Singleton на уровне модуля - Все модули по умолчанию являются синглетонами

• https://docs.python.org/3/library/types.html#types.SimpleNamespace
• https://docs.python.org/3/library/collections.html#collections.namedtuple

class A():
    def cc(self):
        print("cc")

c = A.cc

def ff(self):
    print("ff")
    c(self)

A.cc = ff
a = A()
a.cc()

ff
cc

class A():
    def cc(self):
        print("cc")

a = A()
c = a.cc

def ff(self):
    print("ff")
    c()

A.cc = ff
a = A()
a.cc()

ff
cc

• __name__
• __doc__
• __dict__ - module’s namespace as a dictionary object
• __file__ - is the pathname of the file from which the module was loaded, if it was loaded from a file.
• __annotations__ - optional - dictionary containing variable annotations collected during module body execution

by value:

• immutable:
  • strings
  • integers
  • tuples
  • others…

by reference:

• muttable:
  • objects
  • lists, sets, dicts

• Positional arguments (first, second, third=None, fourth=None) (first, second) - positional, (third, fourth) - Keyword arguments
• Keyword arguments - printinfo( age = 50, name = "miki" ) - order does not metter
• Default arguments - def printinfo( name, age = 35 ):
• Variable-length or Arbitrary Argument Lists positional arguments

def printinfo( arg1, *vartuple ):
  for var in vartuple:
     print (var)
printinfo (1, 'asd','d31', 'cv')

• Variable-length or Arbitrary Argument Lists Keyword arguments

def save_ranking(**kwargs):
  print(kwargs)
save_ranking(first='ming', second='alice', fourth='wilson', third='tom', fifth='roy')
>>> {'first': 'ming', 'second': 'alice', 'fourth': 'wilson', 'third': 'tom', 'fifth': 'roy'}

• both

def save_ranking(*args, **kwargs):
save_ranking('ming', 'alice', 'tom', fourth='wilson', fifth='roy')

Anonymous Functions: - one-line version of a function

lambda [arg1 [,arg2,.....argn]]:expression
(lambda x, y: x + y)(1, 2)

global variables can be accessesd from all functions (except lambda??? - working in console)

# global Money  # Uncomment to replace local Money to global.
  Money = Money + 1 #local

User-defined function

• __doc__
• __name__
• __qualname__
• __module__
• __defaults__
• __code__
• __globals__
• __dict__
• __closure__
• __annotations__

• __kwdefaults__

  Instance methods: read-only attributes:

• __self__ - class instance object
• __func__ - function object
• __module__ - name of the module the method was defined in

• https://docs.python.org/3/glossary.html#term-decorator
• https://www.thecodeship.com/patterns/guide-to-python-function-decorators/

function that get one function and returning another function

• when you need to extend the functionality of functions that you don't want to modify
• @classmethod

Typically used to catch exceptions in wrapper

  def p_decorate(f):
     def inner(name): # wrapper
         # do something here!
         f() # we call wrapped function
     return inner

  my_get_text = p_decorate(get_text) # обертываем, теперь
  my_get_text("John") #о бертка вернет и вызовет вложенную

  #syntactic sugar
  @p_decorate
  def get_text(name):
     return "bla " + name

  #-------------
  get_text = div_decorate(p_decorate(strong_decorate(get_text)))
  # Equal to
  @div_decorate
  @p_decorate
  @strong_decorate

  #-------------- Passing arguments to decorators ------
  def tags(tag_name):
      def tags_decorator(func):
          def func_wrapper(name):
              return "<{0}>{1}</{0}>".format(tag_name, func(name))
          return func_wrapper
      return tags_decorator

  @tags("p")
  def get_text(name):
      return "Hello "+name
  def get_text(name):

https://docs.python.org/3/library/functions.html

abs(x)

absolute value

all(iterable)

all elements of the iterable are true or empty = true

any(iterable)

any element is true or empty = false

ascii(object)

printable representation of an object

breakpoint(*args, **kws)

drops you into the debugger at the call site. calls sys.breakpointhook() which calls calls pdb.set_trace()

callable(object)

if the object - callable type - true. (classes are callable )

@classmethod

function decorator. May be called for class C.f() or for instance C().f() For derived class derived class object is passed as the implied first argument.

class C:
   @classmethod
   def f(cls, arg1, arg2, ...): ...

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

into code or AST object - can be executed by exec() or eval(). Mode - 'exec' if source consists of a sequence of statements. 'eval' if it consists of a single expression

delattr(object, name)

like setattr() - delattr(x, 'foobar') is equivalent to del x.foobar.

divmod(a, b)

ab-two (non complex) numbers = quotient and remainder when using integer division

enumerate(iterable, start=0)

return iterator which returns tuple (0, arg1), (1,arg1) ..

eval(expression, globals=None, locals=None)

string is parsed and evaluated as a Python expression . The globals() and locals() functions returns the current global and local dictionary, respectively, which may be useful to pass around for use by eval() or exec().

exec(object[, globals[, locals]])

object must be either a string or a code object. Be aware that the return and yield statements may not be used outside of function definitions even within the context of code passed to the exec() function. The return value is None.

filter(function, iterable)

Construct an iterator from those elements of iterable for which function returns true.

getattr(object, name[, default])

eturn the value of the named attribute of object. name must be a string or AttributeError is raised

setattr(object, name, value)

assigns the value to the attribute, provided the object allows it

globals()

dictionary representing the current global symbol table (inside a function or method, this is the module where it is defined, not the module from which it is called)x

hasattr(object, string name)

result is True if the string is the name of one of the object’s attributes, False if not

hash(object)

Hash values are integers. Object __hash_₍₎ method.

id(object)

“identity” of an object - integer. Unique and constant during life time. Two objects with non-overlapping lifetimes may have the same id() value.

isinstance(object, classinfo)

True if object is an instance of the classinfo argument.

issubclass(class, classinfo)

true if class is a subclass of classinfo. class is considered a subclass of itself

iter(object[, sentinel])

1) Return an iterator object. __iter_₍₎ or __getitem_₍₎ 2) object must be a callable object __next_₍₎ if the value returned is equal to sentinel, StopIteration will be raised

next(iterator[, default])

__next_₍₎ If default is given, it is returned if the iterator is exhausted

len(s)

.

map(function, iterable, …)

Return an iterator that applies function to every item of iterable. May be applied in parallel to may iterable.

max/min(iterable, *[, key, default])

.

max/min(arg1, arg2, *args[, key])

largest item in an iterable or the largest of two or more arguments

memoryview(obj)

memory view” object

pow(x, y[, z])

(x** y) % z

repr(object)

__repr_₍₎ method - printable representation of an object

reversed(seq)

__reversed_₍₎ method or support sequence protocol (the __len_₍₎ method and the __getitem_₍₎

round(number[, ndigits])

number rounded to ndigits precision after the decimal point

sorted(iterable, *, key=None, reverse=False)

sorted list [] from the items in iterable

@staticmethod

method into a static method.

sum(iterable[, start])

returns the total

super([type[, object-or-type]])

Return a proxy object that delegates method calls to a parent/parents or sibling class of type

vars([object])

__dict__ attribute for a module, class, instance, or any other object

zip(*iterables)

Make an iterator of tuples that aggregates elements from each of the iterables.

• list(zip([1, 2, 3],[1, 2, 3])) = [(1, 1), (2, 2), (3, 3)]
• unzip: list(zip(*zip([1, 2, 3],[1, 2, 3]))) = [(1, 2, 3), (1, 2, 3)]

__import__{(name, globals=None, locals=None, fromlist=(), level=0)}

not needed in everyday Python programming

class bool([x])

standard truth testing procedure see 8.4

class bytearray([source[, encoding[, errors]]])

-mutable If it is a string, you must also give the encoding - it will use str.encode()

class bytes([source[, encoding[, errors]]])

-immutable

class complex([real[, imag]])

complex('1+2j'). - default - 0j

class dict(**kwarg)

dict(one=1, two=2, three=3) = {'one': 1, 'two': 2, 'three': 3}; dict([('two', 2), ('one', 1), ('three', 3)])

class dict(mapping, **kwarg)

????

class dict(iterable, **kwarg)

dict(zip(['one', 'two', 'three'], [1, 2, 3]))

class float([x])

from a number or string x.

class frozenset([iterable])

see 8.3.

class int([x])

x.__int_₍₎ or x.__trunc_₍₎.

class int(x, base=10)

.

class list([iterable])

.

class object

Return a new featureless object.

class property(fget=None, fset=None, fdel=None, doc=None)

class range(stop)

class range(start, stop[, step])

immutable sequence type

class set([iterable])

.

class slice(stop)

.

class str(object='')

.

class str(object=b'', encoding='utf-8', errors='strict')

.

tuple([iterable])

.

class type(object)

object.__class__

class type(name, bases, dict)

.

input([prompt])

return input input from stdin.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Open file and return a corresponding file object.

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

to file or sys.stdout

dir([object])

list of valid attributes for that object. or list of names in the current local scope. __dir_₍₎ - method called - dir() - Is supplied primarily as a convenience for use at an interactive prompt

help([object])

built-in help system

locals()

the current local symbol table

bin(x)

bin(3) -> '0b11'

chr(i)

Return the string representing a character = i - Unicode code

hex(x)

hex(255) = '0xff'

format(value[, format_spec])

https://docs.python.org/3/library/string.html#formatspec

oct(x)

Convert an integer number to an octal string prefixed with “0o”.

ord(c)

c - string representing one Unicode character. Return integer.

from functools import singledispatch

@singledispatch
def func(arg1, arg2):
    print("default implementation of func - ", arg1, arg2)

@func.register
def func_impl_1(arg1: str, arg2):
    print("Implementation of func with first argument as string - ", arg1, arg2)

@func.register
def func_impl_2(arg1: int, arg2):
    print("Implementation of func with first argument as int - ", arg1, arg2)


func(1, "hello")
func("test", "hello")
func(1.34, "hi")

Implementation of func with first argument as int -  1 hello
Implementation of func with first argument as string -  test hello
default implementation of func -  1.34 hi

Arithmetic

• + - *
• / - 9/2 = 4,5 - Division
• % - 9%2 = 1 - Modulus - returns remainder
• ** - Exponent
• // - Floor Division 9 //2 = 4 -9/2 = -5
• += -= *= /= %= **= //=

Comparison = ! <> > < >= <=

Bitwise

• &
• |
• ^ - XOR
• ~ - ~a = 1100 0011
• << - a<<2 = 1111 0000
• >>

Logical - AND - OR - NOT

Membership - in, not in

Identity Operators ( point to the same object) - is, is not

https://docs.python.org/3/reference/expressions.html#operator-precedence

1. Binding or parenthesized expression, list display, dictionary display, set display
   • (expressions…),
   • [expressions…], {key: value…}, {expressions…}
2. Subscription, slicing, call, attribute reference
   • x[index], x[index:index], x(arguments…), x.attribute
3. await x - Await expression
4. ** - Exponentiation [5]
5. +x, -x, ~x - Positive, negative, bitwise NOT
6. *, @, , /, % - Multiplication, matrix multiplication, division, floor division, remainder [6]
7. +, - - Addition and subtraction
8. <<, >> - Shifts
9. & - Bitwise AND
10. ^ - Bitwise XOR
11. | - Bitwise OR
12. in, not in, is, is not, <, <=, >, >=, !=, == - Comparisons, including membership tests and identity tests
13. not x - Boolean NOT
14. and - Boolean AND
15. or - Boolean OR
16. if – else - Conditional expression
17. lambda - Lambda expression
18. := - Assignment expression

old:

1. **
2. ~ + - unary
3. * / % //
4. + -
5. >> <<
6. &
7. ^ |
8. <= < > >=
9. <> = ! Equality operators
10. = %= /= //= -= += *= **= Assignment operators
11. is is not
12. in not in
13. not or and - Logical operators

• a[i:j] - i to j
• s[i:j:k] - slice i to j with step k;

s = range(10) - [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• s[-2] - = 8
• s[1:] - [1, 2, 3, 4, 5, 6, 7, 8, 9]
• s[1::] - [1, 2, 3, 4, 5, 6, 7, 8, 9]
• s[:2] - [0, 1]
• s[:-2] - [0, 1, 2, 3, 4, 5, 6, 7]
• s[-2:] - [8, 9]
• s[::2] - [0, 2, 4, 6, 8]
• s[::-1] -[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

From simple to complex:

1. Iterable - Object that can be used in for, zip, map, in statements - must have __iter_₍₎
2. Iterator - Object with __iter_₍₎ and __next_₍₎. iterator is also iterable.
3. generator - method with yield that magically create iterator, usable in next().

built-in methods

• iter(object) - create Iterable object from list
• iter(object, sentinel) - if the value of __next_₍₎ is equal to sentinel, StopIteration will be raised.
• next(iterator) - call __next_₍₎ method of object.
• next(iterator, default)

Behind the scenes for statement calls iter()- iterator object

• __next_₍₎ - when nothig left - raises a StopIteration exception.

#remove in loop: https://docs.python.org/3/reference/compound_stmts.html#the-for-statement
for f in ret[:]:
  ret.remove(f)

for element in [1, 2, 3]:
    print(element)
for element in (1, 2, 3):
    print(element)
for key in {'one':1, 'two':2}:
    print(key)
for char in "123":
    print(char)
for line in open("myfile.txt"):
    print(line, end='')


class Reverse: # add iterator behavior to your classes
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

rev = Reverse('spam')
for char in rev:
    print(char)

#compact form
>>> t = {x: x*x for x in range(0, 4)}
>>> print(t)
{0: 0, 1: 1, 2: 4, 3: 9}

• for key in a_dict:
• for item in a_dict.items(): - tuple
• for key, value in a_dict.items():
• for key in a_dict.keys():
• for value in a_dict.values():

Since Python 3.6, dictionaries are ordered data structures, so if you use Python 3.6 (and beyond), you’ll be able to sort the items of any dictionary by using sorted() and with the help of a dictionary comprehension:

• sorted_income = {k: incomes[k] for k in sorted(incomes)}
• sorted() - sort keys

form of coroutine

• (expression comp_for) - (x*y for x in range(10) for y in range(x, x+10)) = <generator object>

Yield - используется для создания генератора. используется для создания лопа.

• используется только в функции.
• как return только останавливается после возврата если в лупе или в других случаях
• async def - asynchronous generator - not iterable - <async_generator object -(Coroutine objects)
• async gen - not implement iter and next methods

allow to

def gen_list1(iterable):
    for i in list(iterable):
        yield i

# equal to:
def gen_list2(iterable):
    yield from list(iterable)

#+name example₁

    def hello(func):
    def inner():
        print("Hello ")
        func()
    return inner

@hello
def name():
    print("Alice")

#+name exampl₂

    def star(n):
    def decorate(fn):
        def wrapper(*args, **kwargs):
            print(n*'*')
            result = fn(*args, **kwargs)
            print(result)
            print(n*'*')
            return result
        return wrapper
    return decorate


@star(5)
def add(a, b):
    return a + b


add(10, 20)

• print(f.__name__) of wrapper

• print(f.__doc__) of wrapper

  #+name ex1

       from functools import wraps
  
       class Star:
           def __init__(self, n):
               self.n = n
  
           def __call__(self, fn):
               @wraps(fn) # addition to fix f.__name__ and __doc__
               def wrapper(*args, **kwargs):
                   print(self.n*'*')
                   result = fn(*args, **kwargs)
                   print(result)
                   print(self.n*'*')
                   return result
               return wrapper
  
       @Star(5)
       def add(a, b):
           return a + b
  
       # or
       add = Star(5)(add)
  
       add(10, 20)
  
  
  

new line

• Конец строки - Unix LF, Windows CR LF, Macintosh CR - All of these forms can be used equally, regardless of platform
• In Python - C conventions for newline characters - \n - ASCII LF

Comments

# - line
""" comment """ - multiline

Line joining - cannot carry a comment

if 1900 < year < 2100 and 1 <= month <= 12 \
  and 1 <= day <= 31 and 0 <= hour < 24 # Looks like a valid date

Implicit line joining

month_names = ['Januari', 'Februari', 'Maart',      #you can
               'Oktober', 'November', 'December']   #do it

Blank line - contains only spaces, tabs, formfeeds(FFor \f) and possibly a comment

• Leading whitespace (spaces and tabs)
• determine the grouping of statements
• TabError - if a source file mixes tabs and spaces in a way that makes the meaning dependent on the worth of a tab in spaces

Tabs are replaced - 1-7

[A-Za-z_{(0-9 except for firest char)}] - case sensitive

• and unicode https://www.dcl.hpi.uni-potsdam.de/home/loewis/table-3131.html

Reserved classes of identifiers

• _*
• \_\_\*\_\_
• __*

• integers
• floating point numbers - 3.14 10. .001 1e100 3.14e-10 0e0 3.14₁₅₉₃
• imaginary numbers ????? - 3.14j 10.j 10j .001j 1e100j 3.14e-10j 3.14_1593j

-1 - expression composed of the unary operator ‘-‘ and the literal 1

first thing in a class/function/module

''' This is a multiline comment. '''

• assert
• pass
• del
• return
• yield????
• raise - without argument - re-raise the exception in try except
• break
• continue
• import
• global indentifiers** - tell pareser to treat identifier as global. Когда есть функция и глобальные переменные
• nonlocal indentifier** - когда есть функция внутри функции. переменные в первой функции - не глобальные и не локальные

if shell=True you cannot use array of arguments

• os - portable way of using operating system dependent functionality - files, Command Line Arguments, Environment Variables
  • shutil - higher level interface for files
  • glob - file lists from directory
• logging
• threading - multi-threading
• collections - !!!
• re - regular expression
• math
• statistics
• datetime
• zlib, gzip, bz2, lzma, zipfile and tarfile.
• timeit - performance test
• profile and pstats - tools for identifying time critical sections in larger blocks of code
• doctest - module provides a tool for scanning a module and validating tests embedded in a program’s docstrings.
• unittest
• json
• sqlite3
• Internationalization supported by: gettext, locale, and the codecs package

• https://docs.python.org/3/howto/regex.html

import re

match

если от начала строки совпадает. Возращает объект MatchObject

fullmatch

whole string match

search

до первого вхождения в строке

compile(pattern)

"Компилирует" регулярное выражение, заданное в качестве строки в объект для последующей работы.

sub

replace substring

Флаги:

• re.DOTALL - '.' в регексе означает любой символ кроме пробела, с re.DOTALL включая пробел
• re.IGNORECASE

https://docs.python.org/3/library/filesys.html

• os - lower level than Python "file objects"
• os.path — Common pathname manipulations
• shutil — High-level file operations
• tempfile — Generate temporary files and directories
• Built-in function open() - returns "file object"

file object

pprint.pp(dict/list/file/stdout, indent=4)

d = {'hostnames': [{'name': '', 'type': ''}],
     'addresses': {'ipv4':'49.248.21.1'}}
import pprint
pprint.pp(d, indent=2, width=20)

{ 'hostnames': [ { 'name': '',
                   'type': ''}],
  'addresses': { 'ipv4': '49.248.21.1'}}

with logger

from pprint import pformat
import logging

logging.basicConfig(level=logging.DEBUG, format='%(levelname)-8s %(message)s')

data = [{'hello': 'there'}, {'foo': 'bar'}]

# Use pformat to get a string representation
formatted_data = pformat(data)

# Log the formatted data
logging.debug(formatted_data)

DEBUG    [{'hello': 'there'}, {'foo': 'bar'}]

try:

• # Code that may raise an exception

except ExceptionType:

• # Code to handle the exception

else:

• # Code to execute when no exceptions are raised

finally:

• # Code to execute regardless of exceptions

Words: *try, except, else, finally, raise

• syntax errors - repeats the offending line and displays a little ‘arrow’ pointing
• exceptions
  • last line indicates what happened: stack traceback and ExceptionType: detail based on the type and what caused it
  • exception may have exception’s argument

• BaseException - root exception
• Exception - non-system-exiting exceptions are derived from this class
• Warning - warnings.warn("Warning………..Message")

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ExceptionGroup [BaseExceptionGroup]
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── BrokenPipeError
      │    │    ├── ConnectionAbortedError
      │    │    ├── ConnectionRefusedError
      │    │    └── ConnectionResetError
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    └── RecursionError
      ├── StopAsyncIteration
      ├── StopIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── BytesWarning
           ├── DeprecationWarning
           ├── EncodingWarning
           ├── FutureWarning
           ├── ImportWarning
           ├── PendingDeprecationWarning
           ├── ResourceWarning
           ├── RuntimeWarning
           ├── SyntaxWarning
           ├── UnicodeWarning
           └── UserWarning

two ways

import traceback
import sys

try:
    do_stuff()
except Exception:
    print(traceback.format_exc())
    # or
    print(sys.exc_info()[0])

class LimitException(Exception):
    pass

try:
    raise LimitException(1)
except LimitException as e:
    print(dir(e))
    print(e.args[0])

['__cause__', '__class__', '__context__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__suppress_context__', '__traceback__', '__weakref__', 'add_note', 'args', 'with_traceback']
1

1. loggers: logger = logging.getLogger(name) ; logger.warning("as")
2. root logger: logging.warning('Watch out!')

logging.basicConfig(level=logging.NOTSET)
root_logger = logging.getLogger()

or

logger = logging.getLogger(__name__)
logger.setLevel(logging.NOTSET)

handlers

send the log records (created by loggers) to the appropriate destination.

records

log records (created by loggers)

loggers

expose the interface that application code directly uses.

Filters

provide a finer grained facility for determining which log records to output.

Formatters

specify the layout of log records in the final output.

Multiple calls to getLogger(name) with the same name will always return a reference to the same Logger object.

name - period-separated hierarchical value, like foo.bar.baz

deafult:

• out stderr
• level = WARNING

get all loggers:

[print(name) for name in logging.root.manager.loggerDict]

logger properties:

• logger.level
• logger.handlers
• logger.filters
• logger.root.handlers[0].formatter._fmt - formatter
• logger.root.handlers[0].formatter.default_timeformat

root logger: logging.root or logging.getLogger()

• CRITICAL 50
• ERROR 40
• WARNING 30
• INFO 20
• DEBUG 10
• NOTSET 0

import collections
cnt = Counter()
cnt[word] += 1
most_common(n)

Return a list of the n most common elements and their counts from the most common to the least.

O - provides an upper bound on the growth rate of the function.

x in c:

• list - O(n)
• dict - O(1) O(n)
• set - O(1) O(n)

set

• list - O(1) O(1)
• collections.deque - O(1) O(1) - append
• dict - O(1) O(n)

get

• list - O(1) O(1)
• collections.deque - O(1) O(1) - pop
• dict - O(1) O(n)

https://wiki.python.org/moin/TimeComplexity

• https://www.python.org/dev/peps/
• code style https://www.python.org/dev/peps/pep-0008/

Indentation:

• 4 spaces per indentation level.
• Spaces are the preferred indentation method.

Limit all lines to a maximum of 79 characters.

Surround top-level function and class definitions with two blank lines.

Method definitions inside a class are surrounded by a single blank line.

Inside class:

• capitalizing method names
• prefixing data attribute names with a small unique string (perhaps just an underscore)
• using verbs for methods and nouns for data attributes.

naming conventions

• https://www.python.org/dev/peps/pep-0008/
• Modules should have short, all-lowercase names. Underscores can be used in the module name if it improves readability.
• Python packages should also have short, all-lowercase names, although the use of underscores is discouraged.
• Class Names - CapWords convention
• function names - lowercase with words separated by underscores as necessary to improve readability

Single Underscore: PEP-0008: _single_{leadingunderscore}: weak "internal use" indicator. E.g. from M import * does not import objects whose name starts with an underscore.

Double Underscore: https://docs.python.org/3/tutorial/classes.html#private-variables

• Any identifier of the form __spam (at least two leading underscores, at most one trailing underscore) is textually replaced with _classname__spam, where classname is the current class name with leading underscore(s) stripped. This mangling is done without regard to the syntactic position of the identifier, so it can be used to define class-private instance and class variables, methods, variables stored in globals, and even variables stored in instances. private to this class on instances of other classes.
• Name mangling is intended to give classes an easy way to define “private” instance variables and methods, without having to worry about instance variables defined by derived classes, or mucking with instance variables by code outside the class. Note that the mangling rules are designed mostly to avoid accidents; it still is possible for a determined soul to access or modify a variable that is considered private. ( as a way to ensure that the name will not overlap with a similar name in another class.)

case sensitive

• Class names start with an uppercase letter. All other identifiers start with a lowercase letter.
• Starting an identifier with a single leading underscore indicates that the identifier is private = _i
• two leading underscores indicates a strongly private identifier = __i
• Never use the characters 'l' (lowercase letter el), 'O' (uppercase letter oh), or 'I' (uppercase letter eye) as single character variable names.

Package and Module Names - all-lowercase names. _ - не рекомендуется. C/C++ module has a leading underscore (e.g. _socket). https://peps.python.org/pep-0423/

Class Names - CapWords, or CamelCase

functions and varibles Function and varibles names should be lowercase, with words separated by underscores as necessary to improve readability.

• Always use self for the first argument to instance methods.
• Always use cls for the first argument to class methods.

Constants MAX_OVERFLOW

PEP8

• modules (filenames) should have short, all-lowercase names, and they can contain underscores;
• packages (directories) should have short, all-lowercase names, preferably without underscores;
• classes should use the CapWords convention.

Docstring is a first thing in a module, function, class, or method definition. ( doc special attribute).

• Docstring Conventions https://peps.python.org/pep-0257/
• https://peps.python.org/pep-0258/

Convs.:

• Phrase ending in a period.
• (""" """) are used even though the string fits on one line.
• The closing quotes are on the same line as the opening quotes
• There’s no blank line either before or after the docstring.
• It prescribes the function or method’s effect as a command (“Do this”, “Return that”), not as a description; e.g. don’t write “Returns the pathname …”.
• Multiline: 1. summary 2. blank 3. more elaborate description

problems:

• CPU-Bound Program
• I/O-bound problem - spends most of its time waiting for external operations

types:

• multiprocessing - creating a new instance of the Python interpreter to run on each CPU and then farming out part of your program to run on it.
• threading - Pre-emptive multitasking, The operating system decides when to switch tasks.
  • hard to code, race conditions
• one thread
• Coroutines - Cooperative multitasking - The tasks decide when to give up control.
  • asyncio

modules:

• threading - Thread-based parallelism - fast - better for I/O-bound applications due to the Global Interpreter Lock
• multiprocessing — Process-based parallelism - slow - better for CPU-bound applications
• concurrent.futures - high-level interface for asynchronously executing callables ThreadPoolExecutor or ProcessPoolExecutor.
• subprocess - it’s the recommended option when you need to run multiple processes in parallel or call an external program or external command from inside your Python code. spawn new processes, connect to their input/output/error pipes, and obtain their return codes
• sched - event scheduler
• queue - useful in threaded programming when information must be exchanged safely between multiple thread
• asyncio - coroutine-based concurrency(Cooperative multitasking) The tasks decide when to give up control.

• cannot work with lambdas because of pickle used internaly
• def enter : self._checkrunning()
• def exit : self.terminate()
• r = executor.apply_async ; r.get() - use for debug.

lambdas not supported to apply. Functions should be defined before Pool creation.

cons:

• impossible to catch result of callback
• impossible to pass function to func with additional argument
• require if name == 'main': construction

Daemon - daemon thread will shut down immediately when the program exits. default=False

Python (CPython) is not optimized for thread framework.You can keep allocating more resources and it will try spawning/queuing new threads and overloading the cores. You need to make a design change here:

Process based design:

• Either use the multiprocessing module
• Make use of rabbitmq and make this task run separately
• Spawn a subprocess

Or if you still want to stick to threads:

• Switch to PyPy (faster compared to CPython)
• Switch to PyPy-STM (totally does away with GIL)

• timeout for asyncio run available only at top level in file.
• time.sleep(400) breaks asyncio. Use asyncio.sleep()
• losing of exceptions in subprocesses like Pool.

• to use a top-level try/except block to catch any unhandled exceptions across all tasks.
  • use asyncio.gather with return_exceptions=True
• Ensure that long-running loops are scheduled onto the event loop using methods like loop.call_soon or by breaking them into smaller tasks to avoid halting the event loop.
  • use asyncio.wait with return_when=asyncio.FIRST_COMPLETED to wait until the first task completes.
• Consider keeping a single event loop instance if necessary. Aviod subloops.
• Use asyncio.wait_for to set timeouts for tasks, which helps prevent tasks from running indefinitely. Also, use task.cancel() to cancel tasks that are no longer needed or have timed out.
• Avoid functions with long-running loops within coroutines

• http://hoad.io/blog/playing-with-asyncio/
• https://habr.com/ru/post/337420/

IO-bound and high-level structured network code. synchronize concurrent code;

Any function that calls await needs to be marked with async.

async as a flag to Python telling it that the function about to be defined uses await.

async with statement, which creates a context manager from an object you would normally await.

cons:

• all of the advantages of cooperative multitasking get thrown away if one of the tasks doesn’t cooperate.

asyncio.run - ideally only be called once

• Event Loop - low level the core of every asyncio application, high level: asyncio.run()
• Coroutines (coro) - (async def statement or generator iterator yield or yield from). internally, coroutines are a special kind of generators, every await is suspended by a yield somewhere down the chain of await calls (please refer to PEP 3156 for a detailed explanation).
  • async def - native coroutines
  • yield or yield from - generator-based coroutines

• awaitable object or awaitable proxy object - used for await …

  • native coroutine
  • generator-based coroutine
  • An object with an await method (Future-like) returning an iterator. enable Future objects in await statements, the

  only change is to add await = iter line to asyncio.Future class.

• await accept awaitable object as an argument. Should be used only in async def.

princeples:

• should not be tied to any specific Event Loop implementation (asyncio.events.AbstractEventLoop)
• yield as a signal to the scheduler, indicating that the coroutine will be waiting until an event (such as IO) is completed.
• async def can contain await expressions.
• SyntaxError to have yield or yield from expressions in an async def function.
• Regular generators, when called, return a generator object; similarly, coroutines return a coroutine object.
• decorator @types.coroutine clearly define makes generators a coroutine object, generator-based coroutine.

just create new loop and execute one task in it

with Runner(debug=debug) as runner:
       return runner.run(main)

import time
start_time = time.time()

import asyncio
async def main():
    await asyncio.sleep(2)
    print('hello')
    return 2

print (asyncio.run(main()))
print("--- %s seconds ---" % (time.time() - start_time))
print (asyncio.run(main()))
print("--- %s seconds ---" % (time.time() - start_time))

hello
2
--- 2.0029571056365967 seconds ---
hello
2
--- 4.005870580673218 seconds ---

create loop and ContextVars -

import time
start_time = time.time()

import asyncio
async def main():
    await asyncio.sleep(2)
    print('hello')
    return 2

with asyncio.Runner() as runner:
    print (runner.run(main()))
    print("--- %s seconds ---" % (time.time() - start_time))
    print (runner.run(main()))
    print("--- %s seconds ---" % (time.time() - start_time))

hello
2
--- 2.003290891647339 seconds ---
hello
2
--- 4.006376266479492 seconds ---

timeout=40 available only at top level, not inside ss() normal function

import asyncio
async def run_command():
    print("asd")


def ss():
    try:
        loop = asyncio.get_running_loop()
    except RuntimeError:
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)

    loop.run_until_complete(run_command(), timeout=40) # cause: RuntimeWarning: Enable tracemalloc to get the object allocation traceback
    print("sdff1")
    asyncio.run(run_command())
    print("sdff2")

ss()
# OR JUST
# asyncio.run(run_command()) # out created or exiten loop used

import asyncio
# import time
async def run_command2():
    await asyncio.sleep(22)
    print("222")
    return "ggg"

async def run_command():
    try:
        line = await asyncio.wait_for(run_command2(),
                                      timeout=1.0)
    except TimeoutError:
        print('timeout!')
    print("asd", line)

# def ss():
#     # try:
#     #     loop = asyncio.get_running_loop()
#     # except RuntimeError:
#     #     loop = asyncio.new_event_loop()
#     #     asyncio.set_event_loop(loop)

#     # loop.run_until_complete(run_command()) # , timeout=40 cause: RuntimeWarning: Enable tracemalloc to get the object allocation traceback
#     # print("sdff1")
#     asyncio.run(run_command())
#     print("sdff2")

# ss()
# OR JUST
asyncio.run(run_command()) # out created or exiten loop used

asd
sdff1
asd
sdff2
asd

import asyncio

async def eternity():
    # Sleep for one hour
    await asyncio.sleep(3600)
    print('yay!')

async def main():
    # Wait for at most 1 second
    try:
        await asyncio.wait_for(eternity(), timeout=1.0)
    except TimeoutError:
        print('timeout!')

asyncio.run(main())

timeout!

Object with __aenter_₍₎ and __aexit_₍₎

• lets Python programs perform asynchronous calls when entering and exiting a runtime context
• easy to implement proper database transaction managers for coroutines.

# create and use an asynchronous context manager
async with AsyncContextManager() as manager:
        # ...

#Equal to:
manager = await AsyncContextManager()
try:
        # ...
finally: # see for correct: https://peps.python.org/pep-0492/#new-syntax
        # close or exit the context manager
        await manager.close()



async with lock:
    ...
instead of:

with (yield from lock):
    ...




# easy to implement proper database transaction managers for coroutines:
async def commit(session, data):
    ...

    async with session.transaction():
        ...
        await session.update(data)
        ...

Object with

• __aiter_₍₎ - returns asynchronous iterator object
• __anext_₍₎ - returns awaitable. can rise StopAsyncIteration exception.

Makes it possible to perform asynchronous calls in iterators. see 17.1

aiter() - built-in. Equivalent to calling x.__aiter_₍₎.

class AsyncIterable:
    def __aiter__(self):
        return self

    async def __anext__(self):
        data = await self.fetch_data()
        if data:
            return data
        else:
            raise StopAsyncIteration

    async def fetch_data(self):
        ...

async for TARGET in ITER:
    BLOCK
else:
    BLOCK2

https://peps.python.org/pep-0525/

async def asyncgen():  # an asynchronous generator function
    await asyncio.sleep(0.1)
    yield 42

async for i in asyncgen():
    print(i)

with FastAPI

from collections.abc import AsyncGenerator
async def get_redis_pool() -> AsyncGenerator[Int]:
    yield Int(1)

async def get_redis(r: Redis = Depends(get_redis_pool)) -> Redis:
    return r

RuntimeWarning: coroutine 'sleep' was never awaited   asyncio.sleep(22)
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

Solution

https://docs.python.org/3/library/asyncio.html

Monkey Patching

is about modifying existing code at runtime. Ofter just reassing. (Ruby and Python)

Reflection

is about examining and modifying the structure and behavior of a program at runtime.

Metaprogramming

is about writing code that can manipulate other code at compile time or runtime.

class ExistingClass:
    def __init__(self, value):
        self.value = value


def value_getter(self):
    return self._value
def value_setter(self, value):
    print(f"Value changed {value}")
    self._value = value

# Monkey patch the ExistingClass to add the property setter
ExistingClass.value = property(value_getter, value_setter)

# Create an instance of ExistingClass
obj = ExistingClass(10)

# Change the value of obj
obj.value = 20
print(obj.value)

Value changed 10
Value changed 20
20

• dir() and inspect.getmembers() are basically the same,
• __dict__ is the complete namespace including metaclass attributes.

https://docs.python.org/3/c-api/reflection.html

• Avoid:
  • out = "<html>" + head + prologue + query + tail + "</html>"
• Instead, use
  • out = "<html>%s%s%s%s</html>" % (head, prologue, query, tail)

• map(function, list)
• iterator = (s.upper() for s in oldlist)

• https://docs.python.org/3.8/library/functions.html

primitive calls - without recursion

ncalls

for the number of calls

tottime

time spent inside without subfunctions

percall

tottime/tottime

cumtime

time spent in this and all subfunctions and in recursion

percall

cumtime/ncalls

import cProfile
import re
cProfile.run('re.compile("foo|bar")', filename='restats')
#  pstats.Stats class reads profile results from a file and formats them in various ways.
# python -m cProfile [-o output_file] [-s sort_order] (-m module | myscript.py)

python3 -m timeit '"-".join(str(n) for n in range(100))'

def test():
    """Stupid test function"""
    L = [i for i in range(100)]

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))

python3 -m pdb app.py arg1 arg2

• built-in breakpoint() function that calls pdb.

pdb commands: https://docs.python.org/3/library/pdb.html

• s(step) dive in
• n(next) step over
• unt(il) [lineno]
• r(eturn)
• c(ontinue)
• l . List the source code around the current line or continue list
• b list breakpoints
• clear Clear a breakpoint by its index.
• where Display the current call stack.
• args Print the argument list of the current function.
• p/pp evaluate expression
  • p locals()
  • p globals()
• run/quit

steps:

1. create ~/.pdbrc
2. python -m pdb file.py

b /usr/lib/python3.12/site-packages/redis/cluster.py:1145
commands 1
pp redis_node, connection, command
end
continue

commands:

# b /usr/lib/python3.12/site-packages/redis/cluster.py:1145
# commands 1
# pp redis_node, connection, command
# end

# b /usr/lib/python3.12/site-packages/redis/cluster.py:1143
# # b /usr/lib/python3.12/site-packages/redis/connection.py:275
# commands 1
# pp asking, command, target_node, self.nodes_manager.nodes_cache.values()
# end

# b /usr/lib/python3.12/site-packages/redis/cluster.py:1152
# commands 1
# p "wwwww", response
# end

# # target_node

# b /usr/lib/python3.12/site-packages/redis/cluster.py:1500
# commands 2
# p "----initialize---"
# end
# continue

b /usr/lib/python3.12/site-packages/redis/client.py:310
commands 1
p self.connection_pool
end

https://github.com/ivankorobkov/python-inject

frontend - read pyproject.toml

• pip
• build
• gpep517 - gentoo tool https://github.com/projg2/gpep517
• hatch

backend - defined in [build-system]->build-backend, create the build artifacts, dictates what additional information is required in the pyproject.toml file

• Hatch or Hatchling
• setuptools
• Flit
• PDM

Tom's Obvious Minimal Language