import this # PEP 20, Zen of Python

Narzędzia lintujące (wymuszają dobre praktyki):
  flake8 — sprawdzanie zgodności ze stylem PEP8
  black — automatyczne formatowanie kodu
          (według standardu)
  pylint — bardziej szczegółowa analiza
           jakości kodu
  mypy — sprawdzanie poprawności typów

Zalecenia:
  1. Stosuj PEP 8, PEP 20
  2. Czytelność ważniejsza niż spryt
  3. Używaj typów i adnotacji
  4. List/dict/set comprehensions
     zamiast pętli budujących listy
  5. Enumerate zamiast ręcznego licznika
  6. Zip do łączenia list
  7. Unpacking
  8. Context manager (with)
     zamiast ręcznego otwierania/zamykania
  9. Małe, czytelne funkcje –
     każda powinna robić jedną rzecz.
  10. Docstringi, PEP-257
  11. „DRY” – don’t repeat yourself.
  12. Testy jednostkowe
      (moduł unittest/pytest).
  13. Zasada EAFP:
      „Easier to Ask for Forgiveness than
      Permission”
  14. Zasada SOLID

1. Invoking the Interpreter
$ whereis python3 / interactive Mode (run python3)
$ python3 -c 'from time import sleep;sleep(2);print("I have slept 2 seconds, wow.")'
2. Argument Passing:
• sys.argv
• argparse module
3. sys.stdin:
• $ cat sys_module/short_text_file.txt | python3 sys_module/standard_input.py
standard_input.py

• python3 sys_module/standard_input.py <<EOF
  > 123
  > abc
  > 233342
  >EOF

4. Source Code Encoding: by default UTF-8
• To declare an encoding other than the default one, a special comment line should be added as the first line of the file. Example:
# -*- coding: cp1252 -*-
• One exception to the first line rule is when the source code starts with a UNIX “shebang” line.

#!/usr/bin/env python3
# -*- coding: cp1252 -*-

• floor div (//) returns INT
• raw string r"..." => raw_string.py
• revert: s = '123456789' =>s[-1::-1]
• print(a, end='X', sep=';')
• iterable object
An iterable is any Python object capable of returning its members one at a time, permitting it to be iterated over in a for-loop.
• sequence object
The iterable objects implementing 2 specific methods: '__getitem__()', '__len__()'. So sequences can be Indexed/Sliced.
• immutable object
Values of the object cant be changed (First order values in terms of container like tuple).
Examples of python immutable data structures: int, float, decimal, bool, string, byte, range, tuple
• mutable object
Values of the object can be changed after the object creation.
Examples of python mutable data structures: list, dict, set, custom editable classes

• Python loops:
• if-elif-else, for-else, while-else

• Loops related keywords:
• break, continue, pass

• match statement (added in 3.10):

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

• Defining Functions:
def funct(pos_arg1, pos_arg2=7, /, some_arg3, some_arg4=2, *, k_arg1, k_arg2="dwa")
def funct(argx, argy, argz, *args, **kwargs):
default value: the default value is evaluated only once - during parsing stage
keyword '*'
• arguments after the keyword have to be keyword-like arguments
keyword '/'
• arguments before the keyword have to be positional-like arguments
• Annotations:
• funct(a: str, number: int, dogs: tuple[str]) -> list[str]:
funct.__annotations__
{'a': <class "str">, 'number': <class "int">, 'dogs': tuple[str], 'return': list[str]}
• Docsrings (object.__doc__):
ALL modules should normally have docstrings, and ALL functions and classes exported by a module should also have docstrings
Public methods (including the __init__ constructor) should also have docstrings.
A package may be documented in the module docstring of the __init__.py file in the package directory.
PEP-0257 , Google Style Python Docstrings,

• Python module search algorithm:
1. built-in modules
2. sys.path directories
3. PYTHONPATH env directory
4. Python installation directories
• __all__
• from package import *
• the list of module names when 'from package import *' is encountered.
• python -B [python_file]
• will not write compiled py files like: __pycache__/modx.pyc
• Namespaces in Python:
namespace is the structure used to organize the symbolic names assigned to objects in a Python program
LEGB rule (can be changed by: global/nonlocal keywords)
• LEG are implemented as dictionaries / B as module
• How to see LEGB contents? LE: locals(), G: globals(), dir() and dir(imported_module), B: dir(__builtins__)
• namespaces creation lifetime:
• B: created when the Python interpreter starts up, and is never deleted. It lives as __builtins__
• G (also for module): is created when the module definition is read in; normally, module namespaces also last until the interpreter quits
• LE: is created when the function is called, and deleted when the function returns or raises an exception that is not handled within the function.

• 'open' usage examples:
  
  with open(file=input_file, mode="r+b") as rb_file:
      ...
      # rb_file object has type: _io.BufferedReader
      # r+ - otwórz plik do odczytu i zapisu, ale plik musi istnieć (nie zostanie utworzony)
      # b  – otwórz w trybie binarnym, czyli bez konwersji znaków i końców linii
  
  with open(file=input_file, encoding="utf-8") as file:
       ...
       # file object has type: _io.TextIOWrapper
       #  - __iter__, __next__
       #  - mode="rt" (default)

• try / except / else / finally:

try:
    ~ code to execute
except Error1:
    ~ code to handle Error1
except (Error2, Error3, Error4):
    ~ code to handle Errors2-4
except Error5 as e5:
    ~ code to handle Error5
    ~ print(e5.args) -> printing Exception arguments
except:
    ~ code to handle unexpected errors
else:
    ~ code to be executed if the try clause does not raise an exception
finally:
    ~ code to be executed in very end
    ~ often for cleanup activities
    ~ ... print("Unexpected error:", sys.exc_info()[0])
    ~ ... raise -> we can even read type of exception and handle it

• raise ExceptionName


• builtin exceptions, there are (at least) two distinguishable kinds of errors: syntax errors and exceptions:
• NameError, OSError, KeyboardInterrupt, SyntaxError (Parsing error)
• ImportError, IndexError, KeyError, RuntimeError
• TypeError, AssertionError, ValueError, ZeroDivisionError


• If you need to determine whether an exception was raised but don’t intend to handle it:

try:
  raise NameError('HiThere')
except NameError:
  print('An exception flew by!')
  raise

• raise NewException(..) from OriginalException(..)

Class object creation flow (without __slots__ impact):


• When Interpreter sees 'class' then calling __build_class__(func, name, *bases, **kwargs). Class body is treated as special-function.
• If metaclass has defined __prepare__ (must return a mapping) then it is called else empty dict is passed further as namespace.


• Class body is executed and a new namespace is created and used as the local scope.
• If Class body contains super/__class__ calls then Python creates a cell variable (__classcell__) with __class__ object.
• This ensures that methods inside the class can access __class__, even before the class is fully defined.


• Calling [metaclass/type].__new__(name, bases, namespace)
• custom metaclass can set here own logic like creating attributes, methods (by default type metaclass)
• If class have descriptor methods then '__set_name__(owner, name)' is called (if __set_name__ is defined).


• Calling type.__init__(self, name, bases, namespace).
• For subclasses: type.__init__ calls '__init_subclass__'



• Inheritance
  - isinstance(obj, int)
  - issubclass(float, int)


• super()
  - technically, it is called "proxy object"
  - allows us to avoid using the base class name explicitly
  - working with Multiple Inheritance


• Multiple Inheritance
  - class DerivedClass(Base1, Base2, Base3)
  - Diamond problem solved by: DerivedClass.__mro__


• Privateness
  - “Classic Private” resources accessed only from inside an object don’t exist in Python.
  - Everything about privacy in Python is "Convention":
  - "Pseudo-privacy resource" starts from __ like: __siup are and not accessible directly.
  - but due to Name Mangling the given resource will be available under "_ClassX__siup"
  - "Protected resource" starts from _ like: '_bubu'

---



• Iterators:
An iterator is a class that implements two special methods: __iter__() and __next__().
• __iter__(): This method is called when an iterator is required for an object. It should return the iterator object itself.
• ___next__(): This method should return the next value in the iteration sequence. When there are no more items to return, it should raise the StopIteration exception.



class SquareIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0

    def __iter__(self):
        return self  # The iterator object itself

    def __next__(self):
        if self.current < self.limit:
            result = self.current ** 2
            self.current += 1
            return result
        else:
            raise StopIteration  # No more items to iterate over

# Using the custom iterator
square_iter = SquareIterator(5)  # Squares from 0^2 to 4^2

for square in square_iter:
    print(square)

square_iter2 = SquareIterator(3)  # Squares from 0^2 to 3^2 and raises StopIteration
print(next(square_iter2))
print(next(square_iter2))
print(next(square_iter2))
print(next(square_iter2))

0
1
4
9
16
0
1
4
Traceback (most recent call last):
  File "PATH/iterators.py", line 22, in 
    print(next(square_iter2))
  File "PATH/iterators.py", line 15, in __next__
    raise StopIteration  # No more items to iterate over
StopIteration

iterator class example

---



• Generators:
Generators are a functions which return a generator-iterator objects.
Generator-iterator objects follow Iterator protocol, because of implementing __iter__ and __next__ methods.
Anything that can be done with generators can also be done with class-based iterators.
What makes generators so compact is that the __iter__() and __next__() methods are created automatically.
In addition to automatic method creation and saving program state, when generators terminate, they automatically raise StopIteration.
These features make it easy to create iterators with no more effort than writing a regular function.


Simple generator:

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

for char in reverse('golf'):
    print(char)

f
l
o
g

Great example of usage generators - processing big file:

def read_large_file(file_path):
    with open(file_path) as file:
        for line in file:
            yield line.strip()

for line in read_large_file("big_file.txt"):
    print(line)  # Processing line without loading full file to memory.

Generators advanced features:
• sending data to generators: send(value)
Send starts generator and sends 'value' to yield expression.
First generator call has to be via next or send(None).
• sending exception to generators: throw(Exception, 'Message')
• closing generators by: close()
• delegating to other generators by: yield from
• generator expressions:

gen = (x**2 for x in range(5))
print(next(gen))  # Output: 0
print(next(gen))  # Output: 1

• 10.1. Operating System Interface
os, shutil modules
• 10.2. File Wildcards
glob module
• 10.3. Command Line Arguments
sys.argv
argparse module
example
• 10.4. Error Output Redirection and Program Termination
sys.stderr.write('Warning, log file not found starting a new one\n')
• 10.5. String Pattern Matching

    import re
    re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
    re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat'

    ['foot', 'fell', 'fastest']
    'cat in the hat'

• 10.6. Mathematics
modules: math, random, statistics, secrets
• 10.7. Internet Access
modules: urllib.request, smtplib
• 10.8. Dates and Times
modules: datetime, time
• 10.9. Data Compression
modules: zlib, bx2, lzma, zipfile, tarfile
• 10.10. Performance Measurement
modules: timeit, profile, pstats
• 10.11. Quality Control
modules doctests:

    def average(values):
        """Computes the arithmetic mean of a list of numbers.

        >>> print(average([20, 30, 70]))
        40.0
        """
        return sum(values) / len(values)
    import doctest
    doctest.testmod()   # automatically validate the embedded tests

module unittest:

    import unittest

    class TestStatisticalFunctions(unittest.TestCase):
        def test_average(self):
            self.assertEqual(average([20, 30, 70]), 40.0)
            self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
            with self.assertRaises(ZeroDivisionError):
                average([])
            with self.assertRaises(TypeError):
                average(20, 30, 70)

    unittest.main()  # Calling from the command line invokes all tests

• 10.12. Batteries Included
Python has a “batteries included” philosophy. This is best seen through the sophisticated and robust capabilities of its larger packages. For example:
• The xmlrpc.client and xmlrpc.server modules make implementing remote procedure calls into an almost trivial task.
• email, json, csv, sqlite3 modules
• XML processing is supported by the xml.etree.ElementTree, xml.dom and xml.sax packages
• Internationalization is supported by a number of modules including gettext, locale, and the codecs package.

• 11.1. Output Formatting
reprlib, pprint, textwrap, locale
• 11.2. Templating
string.Template
• 11.3. Working with Binary Data Record Layouts
struct pack and unpack functions
• 11.4. Multi-threading
threading module
CPython implementation detail: In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing or concurrent.futures.ProcessPoolExecutor. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.
threading examples

Unicode and UTF-8 - default in Python

• Unicode - text/symbol representation standard (also emoji and special codes)
• also defined as symbol coding representation system
• UTF-8 - symbol encoding (to bytes) system
• every ASCII text is UTF-8 text
• UTF-8 is default for JSON, XML
• ASCII - symbol encoding (to bytes) system

Python interpreter, it is python-program-responsible for:

• Python source code parsing
• Python source code compiling to bytecode
• Python bytecode execution.

Python execution model:

• The first step of a parsing process is splitting up 'python code' into a list of pieces usually called tokens. (done by tokenize/tokenizer.c module).
• The raw list of tokens is input of a Parser component that transforms them to build an Abstract Syntax Tree (based on Python grammar).
• An AST is a collection of nodes which are linked together based on the grammar of the Python language.
• AST is a later input for a compiling process when a lower level form of instructions called bytecode is generated.

• During compilation, certain constant expressions, such as default argument values, are evaluated.
• This is where the compile() function works – it transforms the AST into bytecode. Python objects such as functions or classes are created at runtime, but their structure is defined during compilation.

• Python interpreter components: Python Virtual Machine (PVM), Frame Stack / Call Stack, Namespaces: Builtins, Globals, Locals.
• PVM — conceptual layer realized by function _PyEval_EvalFrameDefault() in ceval.c (Bytecode interpreter is main part).

Runtime is the phase in Python Execution model when:
    - PVM/PVM Interpreter interprets/executes bytecode (instructions saved in stack frame)
        - knowing that PVM / other C-Function are compiled code = machine code (inside python program) that understands bytecode
        - then Python bytecode is read and executed "instruction after instruction" by PVM (compiled CPython machine code)
          (*** important to see that Python source code is never translated to CPU machine code - at least in CPython)
    + mentioned stack frame mechanism functionalities are performed
    + other mechanisms required functions are executed: GC, exception handling, import system

1. Komponenty fazy parsowania (kod źródłowy Pythona -> AST)
 - Tokenizer / Lexer, Parser


2. Komponenty kompilacji (AST → Bytecode)
    [AST]
       ↓
    [symtable.c] → tworzy mapę nazw
       ↓
    [compile.c] → przekształca AST do bytecode
       ↓
    [codeobject.c] → tworzy finalny PyCodeObject


Bytecode w CPythonie to:
 - zestaw instrukcji wirtualnej maszyny Pythona (PVM) [nie są kodem maszynowym CPU, więc nie są bezpośrednio wykonywane przez CPU]
 - lecz są instrukcjami rozumianymi przez interpreter PVM (czyli część softwarej maszyny PVM).


3. Runtime (Execution stage)
        ┌────────────────────────┐
        │                        │
        │   Python VM (ceval.c)  │ ← główny silnik wykonania
        │     ↓ eval loop        │
        │                        │
        └────────┬───────────────┘
                 │
                 │

    PVM w CPythonie to funkcja _PyEval_EvalFrameDefault() z pliku ceval.c,
     - jej zadaniem jest analiza bytecode krok po kroku, realizując go przez funkcje w C.
     - jej podstawową częścią jest interpreter bytecode'u Pythona.

                 │
                 │
                 │
        ┌────────▼──────────────┐
        │   Call Stack / Frames │ ← wykonanie funkcji, zakresy zmiennych
        └────────┬──────────────┘
                 │
     ┌───────────▼─────────────┐
     │ Memory Mgmt + GC        │ ← alokacja, refcount, GC
     └───────────┬─────────────┘
                 │
        ┌────────▼─────────────┐
        │ Namespaces & Builtins│ ← globals, locals, __builtins__
        └──────────────────────┘

Computational complexity of algorithms:

• What kind of complexity? time performance / memory performance
estimation function basics 1
estimation function basics 2

In Linux it proceeds to understanding below notions / aspects:
    - all resources are eventually provided by kernel
    - virtual memory and other memory management functions
    - concurrency in Python from perspective of memory management
    - Call Stack in Python, Heap memory in Python / processor stack

    - OS level memory optimizations - like using processor cache memory for often used objects:
    - what are other processor / OS memory optimizations technics?
        - Paging and Swapping, Lazy Allocation, Transparent Huge Pages, Memory Overcommit
        - Copy-on-Write (CoW) - kiedy proces tworzy kopię (np. fork), Linux stosuje Copy-on-Write:
            - Pamięć współdzielona między procesami nie jest kopiowana od razu.
        - Kernel Same-page Merging (KSM), NUMA (Non-Uniform Memory Access), Asynchronous I/O i Direct Memory Access (DMA)
        - Reclaiming Memory (odzyskiwanie pamięci), HugeTLB (Huge Translation Lookaside Buffer),
        - Pamięć mapowana na pliki (Memory-Mapped Files), Linux pozwala na mapowanie plików bezpośrednio do pamięci (mmap)
        - Cgroups i limity pamięci, parametr swappiness kontroluje, jak agresywnie Linux korzysta z pamięci wymiany (swap)
        - Linux używa technik takich jak prefetching i readahead, aby przewidywać, jakie dane mogą być potrzebne i ładować je wcześniej

    - Python memory optimization technics:
        - object interning / object sharing
        - freelist - reusing memory - or object caching (often used objects), empty dict are reused
        - constant pool (for constant variables in functions)
        - dynamic memory allocation for mutable objects
        - optimization in hash tables (dicts)
        - Lazy Evaluation i View Objects (Python User level)


Python Call Stack (Pythonowy Stos wywołań):
    - W językach niskopoziomowych, takich jak C, stos wywołań jest zarządzany bezpośrednio przez system operacyjny i procesor.
    - W CPython stos wywołań jest zarządzany interpreter:
        - dodaje to narzut, ale umożliwia np dynamiczne zarządzanie pamięcią (stos odpowiada za zarządzanie pamięcią przy wywoływaniu funkcji)

    Jak to umożliwia dynamiczne zarządzanie pamięcią?
     - Ramki wywołań są dynamiczne i nie muszą mieć z góry określonego rozmiaru — stos wywołań dopasowuje się do rozmiaru wywołań funkcji
     - mniejsze zaangażowanie Garbage Collector
         - GC nie działa bezpośrednio na stosie, gdy funkcja kończy działanie, jej lokalne zmienne są usuwane natychmiast (bez interwencji GC).
         - Liczniki referencji Garbage Collector pozwalają na automatyczne usuwanie obiektów, na które wskazywały referencje ze stosu.
    Narzut związany z dynamicznym zarządzaniem pamięcią:
        - Zarządzanie pamięcią przez licznik referencji - działanie Garbage collectora jest kosztowne pod względem czasowym
        - Zastosowanie dynamicznych ramek wywołań również wiąże się z pewnym kosztem pamięci i czasu.
          Tworzenie i usuwanie ramek wywołań przy każdym wywołaniu funkcji ma swój narzut czasowy.

Heap memory in Python:
    - dynamic virtual memory assigned to the given process (logically it is continual address space)
    - used automatically when objects in Python are created
    - global memory space (subspace of heap memory)
    - Garbage Collector dba o zwalnianie pamięci obiektów przechowywanych na stercie.
    - Kiedy obiekt jest nieosiągalny (nie ma referencji do niego), GC usuwa go z pamięci. Jest to zarządzanie dynamiczne.


More about Call Stacks in Python:

- dokładniej w Pythonie/OS funkcjonują dwa stosy:
  - klasyczny stos procesora. C stack (nowy per proces / wątek)
    - Jest to stos na poziomie systemowym, zarządzany przez system operacyjny i procesor.
    - W przypadku Pythona (zwłaszcza CPython), ten stos jest używany przy wywoływaniu funkcji niskopoziomowych napisanych w C.
    - Interpreter Pythona (który jest implementowany w C w CPythonie) korzysta z tego stosu przy wykonywaniu kodu Pythona.

  - Pythonowy Stos wywołań (nowy per proces / wątek)

    - Stos Pythonowy jest realizowany przy pomocy ramek wywołań (PyFrameObject) - zarządzany przez interpreter
    - dokładniej, w CPython stos wywołań i ramki funkcji są zaimplementowane na poziomie kodu źródłowego interpretera w języku C
    - dzieje się to w: Python/ceval.c: w głównej pętla interpretera, gdzie wykonywany jest bytecode i zarządzane są ramki
        - short-living data like local variable references in function scope that are packed in Frames (when functions are called)
        - upraszaczając Stos wywołań bazuje na polu f_back w PyFrameObject, który wskazuje na poprzednią ramkę (rodzica)
        - Każda ramka odpowiada jednemu wywołaniu funkcji (lub blokowi kodu wykonywanemu przez interpreter, np. w module, klasie, itp.)
        - Dzięki tej konstrukcji Python śledzi historię wywołań i pozwala debugować kod (np. tracebacks w przypadku błędów).

        - Ramki funkcji: PyFrameObject - Include/frameobject.h - kluczowe elementy struktury:
            - f_back: Wskaźnik na poprzednią ramkę. Łączy ramki w stos wywołań
            - f_code: Odniesienie do obiektu kodu (bytecode) odpowiadającego funkcji.
            - f_valuestack: Wskaźnik na stos wartości używanych przez bytecode (np. zmienne, wyniki operacji).
            - f_blockstack: Stos bloków try/except i pętli.

            Generatory, yield:
                - struktura PyGenObject, przechowuje wszystkie informacje potrzebne do wznowienia wykonania generatora po każdym yield
                - działanie ramek funkcji oraz stosu wywołań różni się nieco od standardowego działania funkcji
                - dzięki mechanizmowi yield realizowane jest zatrzymywanie i wznawianie funkcji
                  a ramki funkcji generatora są przechowywane między kolejnymi wywołaniami,
                  co pozwala na efektywne zarządzanie pamięcią i realizację leniwego przetwarzania danych
                - Kiedy interpreter napotyka yield, wykonuje następujące kroki:
                    - Zapisuje stan funkcji (ramkę: PyFrameObject) do struktury obiektu generatora (PyGenObject).
                    - Zwraca kontrolę do wywołującego kodu i wartość, którą zdefiniowano przy "yield var_value"

                - Generatory są przydatne w sytuacjach, gdy nie musisz przechowywać wszystkich wartości w pamięci na raz:
                  (Kiedy generator naprawdę oszczędza pamięć?)
                    - Use Case 1: Iterowanie przez wartości bez ich przechowywania (przetwarzanie dużych zbiorów danych)
                    - Use Case 2: Przetwarzanie danych w strumieniu (stream processing)
                    - Use Case 3: Obsługa nieskończonych sekwencji
                    - Use Case 4: Przetwarzanie dużych plików z logami
                        - dzięki generatorowi możesz wczytywać/przetwarzać plik linia po linii bez przechowywania całego pliku w pamięci
                - Istotne - Kiedy generatory nie są potrzebne?
                    - gdy musisz przechowywać wszystkie generowane wartości w pamięci
                    - gdy potrzebujesz wielokrotnego dostępu do wyników (np. musisz iterować przez te same dane wiele razy)

            asyncio, korutyny:
                - Stos Pythonowy, w przypadku korutyn (async def) działa to trochę inaczej
                - każda korutyna ma swój własny kontekst wykonania, który przechowuje dane lokalne i stan wywołania
                - Zamiast typowego stosu ramek funkcji, korutyna "zamraża" swój stan w obiekcie CoroWrapper (zarządzanym przez pętlę zdarzeń)
                    - gdy korutyna jest "zamrażana" Pętla zdarzeń usuwa jej ramkę ze stosu Pythonowego
                    - wznowienie korutyny powoduje również przywrócenie jej ramki na stos Pythonowy

• Introduction
• Built-in Functions
• abs, aiter, all, anext, any, ascii, bin, bool, breakpoint, callable, chr, classmethod, compile, complex,
• delattr, dir, divmod, enumerate, eval, exec, filter, float, format, getattr, globals, hasattr, hash, help,
• id, input, int, isinstance, issubclass, iter, len, locals, map, max, min, next, object, oct, open, ord,
• pow, print, property, repr, reversed, round, setattr, slice, sordeted, staticmethod, sum, super, type, vars, zip, __import__
• Built-in Constants
• Built-in Exceptions
• Text Processing Services
• Binary Data Services
• Data Types
• Numeric and Mathematical Modules
• Functional Programming Modules
• File and Directory Access
• Data Persistence
• Data Compression and Archiving
• File Formats
• Cryptographic Services
• Generic Operating System Services
• Concurrent Execution
• Networking and Interprocess Communication
• Internet Data Handling
• Structured Markup Processing Tools
• Internet Protocols and Support
• Multimedia Services
• Internationalization
• Program Frameworks
• Graphical User Interfaces with Tk
• Development Tools
• Debugging and Profiling
• Software Packaging and Distribution
• Python Runtime Services
• Custom Python Interpreters
• Importing Modules
• Python Language Services
• MS Windows Specific Services
• Unix Specific Services
• Modules command-line interface (CLI)
• Superseded Modules
• Removed Modules
• Security Considerations

Python garbage collection (GC)

• Reference counting, mechanism of counting how many times object is used.
• Cycle detection, mechanism for finding object referencing each other.

GIL (Global Interpreter Lock)

• What problems GIL solves for Python?
• Multi-threading access potential issues.
• Race Conditions in Reference Counting (Garbage Collection).
• Complexity of Fine-Grained Locks. The GIL ensures safety and simplicity.
• Why Was the GIL Chosen as the Solution?
• Simplicity and performance aspects.
• The Impact on Multi-Threaded Python Programs.
• Multi-threading in Python doesn't achieve true parallelism on multi-core processors (except in specific cases, like I/O-bound operations or extensions written in C that release the GIL).
• Why Hasn’t the GIL Been Removed Yet?
• Due to several reasons being a combination of technical complexity, backward compatibility concerns, and trade-offs in performance and simplicity.

Metaprogramming / Metaclass

• Dynamic Class Creation: Creating classes at runtime.

Foo = type('Foo', ('FooBase1', 'FooBase2'), {'attr': 100,'attr_val': lambda x : x.attr})

• Decorators: Functions that modify the behavior of other functions or methods or classes.
• Descriptors are objects that manage the access to attributes of other objects.
• objects with manipulated dunder methods: __get__, __set__, __delete__
• Magic Methods: Special methods that let you control how Python interacts with objects (e.g., __getattr__, __setattr__).
• exec() and eval(): Functions for dynamic execution of Python code.

    class Meta(type):
        def __new__(cls, name, bases, dct):
            x = super().__new__(cls, name, bases, dct)
            x.attr = 100
            return x

    class Foo(metaclass=Meta):
        pass

>>> Foo.attr
100

Descriptors

Descriptors are a powerful, general purpose protocol.
    - If an object defines __set__() or __delete__(), it is considered a data descriptor.
    - They are the mechanism behind properties, methods, static methods, class methods, and super()
        - If an object defines __set__() or __delete__(), it is considered a data descriptor.
        - Descriptors that only define __get__() are called non-data descriptors (they are often used for methods but other uses are possible).
    - Descriptor invocation logic: The mechanism for descriptors is embedded in the __getattribute__() methods for object, type, and super().
        - Overriding __getattribute__() prevents automatic descriptor calls because all the descriptor logic is in that method.
    - __set_name__ - Customized names - The implementation details are in type_new() and set_names() in Objects/typeobject.c

Basic Descriptor protocol:
    __get__(self, obj, objtype) – returns attribute value (can be calculated).
    __set__(self, obj, value) – set attribute value
    __delete__(self, obj) – delete attribute

Mechanics of Descriptor invocation logic:
    - Descriptors are invoked by the __getattribute__() method.
    - Classes inherit this machinery from object, type, or super().
    - object.__getattribute__() and type.__getattribute__() make different calls to __get__().
    - All functions written in Python are descriptors (have __get__), when functions written in C are not.

So, Descriptors Use Cases:
    - mechanism behind properties, bound methods, static methods, class methods, and super()
    also:
    - Dynamics lookups
    - Logged Access
    - Custom Validators
    - Customized attribute names
    - data descriptors could be used to implement an ORM

Python protocols:

    - Can Python be named protocol oriented language?

    - Class creation protocol
    - Sequence protocol
    - Attribute access protocol
    - Iterable Protocol
    - Numeric Protocol
    - Context Manager protocol
    - Callable protocol
    - Descriptor protocol
    - Buffer protocol
    - Set protocol
    - Async Protocols