it = iter(range(100))
 print(it.__length_hint__())
 # 100
 next(it)
 print(it.__length_hint__())
 # 99
 
 a = [1, 2, 3, 4, 5]
 it = iter(a)
 print(it.__length_hint__())
 # 5
 next(it)
 print(it.__length_hint__())
 # 4
 a.append(6)
 print(it.__length_hint__())
 # 5

class Pet:
     def __init_subclass__(cls, /, default_breed, **kwargs):
         super().__init_subclass__(**kwargs)
         cls.default_breed = default_breed
 
 class Dog(Pet, default_name="German Shepherd"):
     pass

class CallableClass:
     def __call__(self, *args, **kwargs):
         print("I was called!")
 
 instance = CallableClass()
 
 instance()
 # I was called!

class NoInstances(type):
     def __call__(cls, *args, **kwargs):
         raise TypeError("Can't create instance of this class")
 
 class SomeClass(metaclass=NoInstances):
     @staticmethod
     def func(x):
         print('A static method')
 
 instance = SomeClass()
 # TypeError: Can't create instance of this class

class Singleton(type):
     def __init__(cls, *args, **kwargs):
         cls.__instance = None
         super().__init__(*args, **kwargs)
 
     def __call__(cls, *args, **kwargs):
         if cls.__instance is None:
             cls.__instance = super().__call__(*args, **kwargs)
             return cls.__instance
         else:
             return cls.__instance
 
 class Logger(metaclass=Singleton):
     def __init__(self):
         print("Creating global Logger instance")

class Document:
     def __init__(self, text):
         self.text = text
 
 bare_document = Document.__new__(Document)
 print(bare_document.text)
 # AttributeError: 'Document' object has no attribute 'text'
 
 setattr(bare_document, "text", "Text of the document")

class Document:
     def __init__(self, text):
         self.text = text
     
     @classmethod
     def from_file(cls, file):  # Alternative constructor
         d = cls.__new__(cls)
         # Do stuff...
         return d

class String:
     def __init__(self, value):
         self._value = str(value)
 
     def custom_operation(self):
         pass
 
     def __getattr__(self, name):
         return getattr(self._value, name)
 
 s = String("some text")
 s.custom_operation()  # Calls String.custom_operation()
 print(s.split())  # Calls String.__getattr__("split") and delegates to str.split
 # ['some', 'text']
 
 print("some text" + "more text")
 # ... works
 print(s + "more text")
 # TypeError: unsupported operand type(s) for +: 'String' and 'str'

def logger(cls):
     original_getattribute = cls.__getattribute__
 
     def getattribute(self, name):
         print(f"Getting: '{name}'")
         return original_getattribute(self, name)
 
     cls.__getattribute__ = getattribute
     return cls
 
 @logger
 class SomeClass:
     def __init__(self, attr):
         self.attr = attr
 
     def func(self):
         ...
 
 instance = SomeClass("value")
 instance.attr
 # Getting: 'attr'
 instance.func()
 # Getting: 'func'

# some_module/__init__.py
 __all__ = ["func", "some_var"]
 
 some_var = "data"
 some_other_var = "more data"
 
 def func():
     return "hello"
 
 # -----------
 
 from some_module import *
 
 print(some_var)
 # "data"
 print(func())
 # "hello"
 
 print(some_other_var)
 # Exception, "some_other_var" is not exported by the module

from pathlib import Path
 
 print(__file__)
 print(Path(__file__).resolve())
 # /home/.../directory/examples.py
 
 # Or the old way:
 import os
 print(os.path.dirname(os.path.abspath(__file__)))
 # /home/.../directory/

# Directory structure:
 # .
 # |____some_dir
 #   |____module_three.py
 #   |____module_two.py
 #   |____module_one.py
 
 from pathlib import Path, PurePath
 modules = list(Path(__file__).parent.glob("*.py"))
 print([PurePath(f).stem for f in modules if f.is_file() and not f.name == "__init__.py"])
 # ['module_one', 'module_two', 'module_three']

# example.py
 def func():
     if __debug__:
         print("debugging logs")
 
     # Do stuff...
 
 func()

python example.py

python -O example.py