Python 3

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

    def __str__(self):
        return f"Sample with value {self.value}"

obj = Sample(10)
print(obj)

# Создание списка (последовательности)
my_list = [1, 2, 3, 4]

# Индексирование
print(my_list[0])  # Output: 1

# Срезы
print(my_list[1:3])  # Output: [2, 3]

# Итерация
for item in my_list:
    print(item)

# Обычная строка
s1 = 'Hello, World!'

# Многострочная строка
s2 = '''This is
a multiline
string.'''

# Форматированная строка
name = "Alice"
s3 = f"Hello, {name}!"

# Сырая строка
s4 = r"C:\new_folder\test.txt"

original_string = "hello"
new_string = original_string.replace("e", "a")
print(new_string)  # hallo

string = "Привет, мир!"
encoded_string = string.encode('utf-8')
print(encoded_string)  # Вывод: b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82, \xd0\xbc\xd0\xb8\xd1\x80!'

decoded_string = encoded_string.decode('utf-8')
print(decoded_string)  # Вывод: Привет, мир!

# Список
my_list = [1, 2, 3]
my_list.append(4)

# Кортеж
my_tuple = (1, 2, 3)
# my_tuple.append(4)  # это вызовет ошибку, поскольку кортеж неизменяем

r = range(0, 10, 2)
for i in r:
    print(i)

my_list = [1, 2, 2, 3, 4, 4, 5]
unique_list = list(set(my_list))
print(unique_list)  # Выведет [1, 2, 3, 4, 5]

my_list = [1, 2, 2, 3, 4, 4, 5]
unique_list = list(dict.fromkeys(my_list))
print(unique_list)  # Выведет [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3)
a, b, c = my_tuple

[1, 2, 3] < [1, 2, 4]  # True
'apple' > 'app'       # True
(1, 2) == (1, 2, 0)   # False

# Проверка хэшируемого объекта
print(hash(42))        # Целое число
print(hash('hello'))   # Строка
print(hash((1, 2)))    # Кортеж

# Создание множества
my_set = {1, 2, 3, 4, 5}

# Добавление элемента
my_set.add(6)

# Объединение
another_set = {4, 5, 6, 7}
union_set = my_set | another_set

# Пересечение
intersection_set = my_set & another_set

# Разность
difference_set = my_set - another_set

a | b

a & b

a - b

a ^ b

a <= b

a >= b

a.add(element)

a.remove(element)

a.discard(element)

a.clear()

set1 = {1, 2, 3}
set2 = {3, 1, 2}

print(set1 == set2)  # Вывод: True

my_dict = {
    "ключ1": "значение1",
    "ключ2": "значение2"
}

print(my_dict["ключ1"])  # Output: значение1

my_dict = {
    1: "integer",
    1.0: "float",
    True: "boolean"
}

print(my_dict)  # Вывод: {1: 'boolean'}

my_dict = {'a': 1, 'b': 2, 'c': 3}
items = my_dict.items()
print(items)

dict_items([('a', 1), ('b', 2), ('c', 3)])

data = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 20},
    {"name": "Charlie", "age": 30}
]

# Сортировка по полю 'age'
sorted_data = sorted(data, key=lambda x: x["age"])

my_dict = {
    1: "one",
    "two": 2,
    (3, 4): "tuple key"
}

keys = ['a', 'b', 'c']
values = [1, 2, 3]

# Создаем словарь
result_dict = dict(zip(keys, values))

print(result_dict)

{'a': 1, 'b': 2, 'c': 3}

names = ['Anna', 'Bob', 'Claire']
ages = [20, 25, 30]
result = zip(names, ages)
print(list(result))  # Вывод: [('Anna', 20), ('Bob', 25), ('Claire', 30)]

# Создание хэш-таблицы
hash_table = {}

# Вставка элементов
hash_table['key1'] = 'value1'
hash_table['key2'] = 'value2'

# Поиск элемента
value = hash_table.get('key1')
print(value)  # Output: value1

# Обработка коллизий происходит автоматически

def example_function(*args, **kwargs):
    print("Args:", args)
    print("Kwargs:", kwargs)

example_function(1, 2, 3, a=4, b=5)

 
a = 5
b = 3
result = a * b  # result будет равно 15
     

 
word = "Hi"
repeated = word * 3  # repeated будет равно "HiHiHi"
     

 
def func(a, b, c):
    print(a, b, c)

args = (1, 2, 3)
func(*args)  # вызовет func(1, 2, 3)
     

 
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = [*list1, *list2]  # combined_list будет равно [1, 2, 3, 4, 5, 6]
     

 
base = 2
exponent = 3
result = base ** exponent  # result будет равно 8
     

 
def func(a, b, c):
    print(a, b, c)

kwargs = {'a': 1, 'b': 2, 'c': 3}
func(**kwargs)  # вызовет func(a=1, b=2, c=3)
     

 
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
combined_dict = {**dict1, **dict2}  # combined_dict будет равно {'a': 1, 'b': 2, 'c': 3, 'd': 4}
     

def append_to_list(value, my_list=[]):
    my_list.append(value)
    return my_list

# Первый вызов — всё работает как ожидалось
print(append_to_list(1))  # Вывод: [1]

# Второй вызов — неожиданный результат
print(append_to_list(2))  # Вывод: [1, 2]

def append_to_list(value, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(value)
    return my_list

# Первый вызов — ожидаемый результат
print(append_to_list(1))  # Вывод: [1]

# Второй вызов — также ожидаемый результат
print(append_to_list(2))  # Вывод: [2]

def apply_function(func, value):
    return func(value)

def square(x):
    return x * x

result = apply_function(square, 5)
print(result)  # Вывод: 25

def outer_function():
    def inner_function():
        print("Hello from the inner function!")
    
    inner_function()  # Вызов внутренней функции внутри внешней функции

outer_function()  # Вызов внешней функции

add = lambda x, y: x + y
print(add(2, 3))  # Вывод: 5

lambda x: pass  # SyntaxError

lambda x: raise ValueError("Error")  # SyntaxError

def modify_list(lst):
    lst.append(4)

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # Output: [1, 2, 3, 4]

def modify_number(num):
    num += 10

my_number = 5
modify_number(my_number)
print(my_number)  # Output: 5

def outer_function(text):
    def inner_function():
        print(text)
    return inner_function

closure = outer_function("Hello, World!")
closure()  # Выведет "Hello, World!"

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

my_iterable = MyIterator([1, 2, 3])
for item in my_iterable:
    print(item)

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

gen = count_up_to(5)
for num in gen:
    print(num)

def generator():
    yield 1
    yield 2
    yield 3

gen = generator()
print(next(gen))  # Выведет 1
print(next(gen))  # Выведет 2
print(next(gen))  # Выведет 3

[выражение for элемент in итератор if условие]

# Создание списка квадратов чисел от 0 до 9
squares = [x**2 for x in range(10)]
print(squares)

{ключ: значение for элемент in итератор if условие}

# Создание словаря, где ключ - это число, а значение - его квадрат
squares_dict = {x: x**2 for x in range(10)}
print(squares_dict)

list_comp = [x for x in range(10)]  # [0, 1, 2, 3, ..., 9]

gen_expr = (x for x in range(10))  #  <generator object >

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()

print(next(gen))  # Выведет 1
print(next(gen))  # Выведет 2
print(next(gen))  # Выведет 3

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

gen_exp = (x * x for x in range(10))

# Генератор
gen = (x * x for x in range(5))

# Преобразование в список
lst = list(gen)

print(lst)  # Вывод: [0, 1, 4, 9, 16]

def subgenerator():
    yield 1
    yield 2
    yield 3

def delegator():
    yield from subgenerator()
    yield 4

for value in delegator():
    print(value)

def generator():
    try:
        yield 1
        yield 2
    except GeneratorExit:
        print("Generator closed")
    except Exception as e:
        print(f"Exception: {e}")

gen = generator()

print(next(gen))  # 1
gen.send(None)    # Equivalent to next(gen)
gen.throw(ValueError, "An error")  # Raises ValueError inside the generator
gen.close()  # Closes the generator

gen = (x for x in range(10))
lst = list(gen)
print(lst[3])  # Вернет 3-й элемент

my_dict = {'a': 1, 'b': 2, 'c': 3}

for key in my_dict:
    print(key)

# Итерация по ключам и значениям
for key, value in my_dict.items():
    print(key, value)

# Итерация только по значениям
for value in my_dict.values():
    print(value)

my_dict = {'a': 1, 'b': 2, 'c': 3}

for key, value in my_dict.items():
    print(f"Ключ: {key}, Значение: {value}")

import asyncio

async def my_coro():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(my_coro())

def my_generator():
    yield 1
    yield 2
    yield 3

for value in my_generator():
    print(value)
     

import asyncio

async def my_coroutine():
    await asyncio.sleep(1)
    print("Coroutines in Python")

async def main():
    await my_coroutine()

asyncio.run(main())
     

class MyClass:
    def __init__(self):
        self.attribute1 = "value1"
        self.attribute2 = "value2"

obj = MyClass()
print(dir(obj))

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

    def __str__(self):
        return f"MyClass with value: {self.value}"

obj = MyClass(10)
print(obj)  # Вызовет метод __str__

class Parent:
    def greet(self):
        print("Hello from Parent")

class Child(Parent):
    def greet(self):
        super().greet()
        print("Hello from Child")

c = Child()
c.greet()

Hello from Parent
Hello from Child

class Parent:
    def __init__(self):
        print("Parent init")

    def greet(self):
        print("Hello from Parent")

class Child(Parent):
    def __init__(self):
        super().__init__()  # вызовет Parent.__init__()
        print("Child init")

    def greet(self):
        super().greet()  # вызовет Parent.greet()
        print("Hello from Child")

c = Child()
c.greet()

class A:
    pass

class B:
    pass

class C(A, B):
    pass

import copy

original = [1, 2, [3, 4]]
shallow_copy = copy.copy(original)

print(shallow_copy)  # [1, 2, [3, 4]]
shallow_copy[2][0] = "changed"
print(original)  # [1, 2, ["changed", 4]]

import copy

original = [1, 2, [3, 4]]
deep_copy = copy.deepcopy(original)

print(deep_copy)  # [1, 2, [3, 4]]
deep_copy[2][0] = "changed"
print(original)  # [1, 2, [3, 4]]

a = [1, 2, 3]
b = a

print(id(a))  # Выводит идентификатор объекта a
print(id(b))  # Выводит тот же идентификатор, что и a
print(a is b)  # True, так как обе переменные ссылаются на один объект

obj = [1, 2, 3]
print(type(obj))            #  <class 'list'>
print(id(obj))              # Уникальный идентификатор объекта
print(dir(obj))             # Список атрибутов и методов объекта
print(hasattr(obj, "append"))  # True

class MyClass:
    def __init__(self):
        self.name = "MyClass"

    def my_method(self):
        return "Method called"

obj = MyClass()

method_name = "my_method"
method = getattr(obj, method_name)
print(method())  # Method called

setattr(obj, "new_attr", "New Value")
print(obj.new_attr)  # New Value

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

print(D.mro())

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

class A:
    def greeting(self):
        print("Hello from A")

class B(A):
    def greeting(self):
        print("Hello from B")

class C(A):
    def greeting(self):
        print("Hello from C")

class D(B, C):
    pass

d = D()
d.greeting()
print(D.mro())

class FlyableMixin:
    def fly(self):
        return "I can fly!"

class SwimmableMixin:
    def swim(self):
        return "I can swim!"

class Duck(FlyableMixin, SwimmableMixin):
    def quack(self):
        return "Quack!"

# Использование миксинов
duck = Duck()
print(duck.fly())   # Вывод: I can fly!
print(duck.swim())  # Вывод: I can swim!
print(duck.quack()) # Вывод: Quack!

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self
    
    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")

# Использование
with MyContextManager():
    print("Inside the context")

from contextlib import contextmanager

@contextmanager
def my_context():
    print("Entering the context")
    try:
        yield
    finally:
        print("Exiting the context")

# Использование
with my_context():
    print("Inside the context")

a = object()
b = object()

print(a == b)  # Output: False

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # True, значения списков равны
print(a is b)  # False, разные объекты

c = a
print(a is c)  # True, c и a указывают на один и тот же объект

class MyClass:
    __slots__ = ['attribute1', 'attribute2']

    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2

obj = MyClass('value1', 'value2')

class MyClass:
    def __init__(self):
        self._private_var = 1     # одинарное подчёркивание
        self.__name_mangled = 2   # двойное подчёркивание

# Доступ к переменным
obj = MyClass()
print(obj._private_var)          # Работает: 1
# print(obj.__name_mangled)      # Ошибка
print(obj._MyClass__name_mangled) # Работает: 2

class MyClass:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)
        print("Creating instance")
        return instance

    def __init__(self, value):
        self.value = value
        print("Initializing instance")

obj = MyClass(5)

class Bird:
    def quack(self):
        print("Quack")

class Duck:
    def quack(self):
        print("Quack quack")

def make_it_quack(duck):
    duck.quack()

# Оба объекта будут работать, так как оба имеют метод quack
duck = Duck()
bird = Bird()

make_it_quack(duck)
make_it_quack(bird)

from math import sqrt

import math

# example_module.py
print(__name__)

import sys
print(sys.path)

my_package/
    __init__.py
    module1.py
    module2.py
    sub_package/
        __init__.py
        module3.py

import my_package.module1
from my_package import module2
from my_package.sub_package import module3

import module_name

from module_name import function_name

import module_name as alias

try:
    # Код, который может вызвать исключение
    результат = 10 / 0
except ZeroDivisionError:
    # Код для обработки исключения
    print("Деление на ноль невозможно")

try:
    # Код, который может вызвать исключение
    файл = open("не_существующий_файл.txt", "r")
except FileNotFoundError:
    # Обработка исключения FileNotFoundError
    print("Файл не найден")
except Exception as e:
    # Обработка всех остальных исключений
    print(f"Произошла ошибка: {e}")
else:
    # Выполняется, если исключение не было вызвано
    содержимое = файл.read()
    print(содержимое)
finally:
    # Выполняется в любом случае
    print("Завершение работы с файлом")
    файл.close()

try:
    # Код, который может вызвать исключение
finally:
    # Код, который выполняется всегда

try:
    # Код, который может вызвать исключение
    result = 10 / 0
except ZeroDivisionError as e:
    # Обработка исключения
    print(f"Исключение поймано: {e}")
else:
    # Этот блок выполнится, если исключения нет
    print("Ошибок нет, результат:", result)
finally:
    # Этот блок выполнится в любом случае
    print("Блок finally выполнен")

def func1():
    raise ValueError("An error occurred")

def func2():
    func1()

def main():
    func2()

main()

Traceback (most recent call last):
  File "example.py", line 9, in <module>
    main()
  File "example.py", line 7, in main
    func2()
  File "example.py", line 4, in func2
    func1()
  File "example.py", line 2, in func1
    raise ValueError("An error occurred")
ValueError: An error occurred

try:
    # Код, который может вызвать исключение
    some_function()
except SomeException as e:
    # Действия, которые нужно выполнить при исключении
    log_error(e)
    # Повторное возбуждение того же исключения
    raise

try:
    result = some_risky_function()
except SomeException as e:
    handle_exception(e)
else:
    do_something_if_no_exception()

class MyCustomError(Exception):
    """Описание вашего исключения."""
    pass

try:
    raise MyCustomError("Произошла ошибка!")
except MyCustomError as e:
    print(e)

class MyException(Exception):
    def __init__(self, message, code=None, extra_data=None):
        super().__init__(message)
        self.code = code
        self.extra_data = extra_data

try:
    raise MyException("An error occurred", code=500, extra_data={'key': 'value'})
except MyException as e:
    print(e)                      # An error occurred
    print(e.code)                 # 500
    print(e.extra_data)           # {'key': 'value'}

import warnings

def deprecated_function():
    warnings.warn("This function is deprecated", DeprecationWarning)

deprecated_function()

import warnings

def my_function():
    warnings.warn("This is a custom warning", UserWarning)

my_function()

def my_decorator(func):
    def wrapper():
        print("Что-то делаем до запуска функции")
        func()
        print("Что-то делаем после запуска функции")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Что-то делаем до запуска функции
Hello!
Что-то делаем после запуска функции

def decorator_func(func):
    def wrapper():
        print("Before")
        result = func()
        print("After")
        return result
    return wrapper

@decorator_func
def say_hello():
    print("Hello!")
    
say_hello()

class DecoratorClass:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before")
        result = self.func(*args, **kwargs)
        print("After")
        return result

@DecoratorClass
def say_hello():
    print("Hello!")
    
say_hello()

def decorator_with_args(arg1, arg2):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"Arguments received: {arg1}, {arg2}")
            result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@decorator_with_args("hello", "world")
def say_hello():
    print("Hello!")
    
say_hello()

from functools import wraps

def decorator_func(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Before")
        result = func(*args, **kwargs)
        print("After")
        return result
    return wrapper

@decorator_func
def say_hello():
    print("Hello!")
    
say_hello()
print(say_hello.__name__)

def my_decorator(cls):
    class WrappedClass(cls):
        def new_method(self):
            return "This is a new method"
    return WrappedClass

@my_decorator
class MyClass:
    def __init__(self, value):
        self.value = value

    def display(self):
        return f'Value: {self.value}'

# Использование:
obj = MyClass(10)
print(obj.display())      # Вывод: Value: 10
print(obj.new_method())   # Вывод: This is a new method

def log_methods(cls):
    import logging
    logging.basicConfig(level=logging.INFO)
    
    class WrappedClass(cls):
        def __getattribute__(self, name):
            attr = super().__getattribute__(name)
            if callable(attr):
                def newfunc(*args, **kwargs):
                    logging.info(f"Calling method {name}")
                    return attr(*args, **kwargs)
                return newfunc
            return attr

    return WrappedClass

@log_methods
class MyClass:
    def method_1(self):
        print("Method 1")

    def method_2(self):
        print("Method 2")

# Использование:
obj = MyClass()
obj.method_1()  # Вывод в лог: Calling method method_1
obj.method_2()  # Вывод в лог: Calling method method_2

def my_function():
    pass

print(callable(my_function))  # Вывод: True

class MyCallable:
    def __call__(self):
        pass

my_callable = MyCallable()
print(callable(my_callable))  # Вывод: True

def decorator_factory(parameter):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"Parameter: {parameter}")
            result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@decorator_factory("Hello")
def example_function():
    print("Function called.")

example_function()

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Calling decorated function")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def example():
    """Example function documentation."""
    print("Example function")

print(example.__name__)  # Выведет: example
print(example.__doc__)   # Выведет: Example function documentation.

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        # Добавляем новый метод в создаваемый класс
        dct['new_method'] = lambda self: "Метод добавлен метаклассом"
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    pass

obj = MyClass()
print(obj.new_method())  # Выведет "Метод добавлен метаклассом"

x = 10
print(type(x))  # <class 'int'>

MyClass = type('MyClass', (object,), {'attr': 42})
instance = MyClass()
print(instance.attr)  # 42

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        if 'my_method' not in dct:
            raise TypeError("Must have 'my_method'")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    def my_method(self):
        pass

   import json
   data = {'name': 'Alice', 'age': 25}
   json_string = json.dumps(data)
   

   import json
   data = {'name': 'Alice', 'age': 25}
   with open('data.json', 'w') as file:
       json.dump(data, file)
   

   import json
   json_string = '{"name": "Alice", "age": 25}'
   data = json.loads(json_string)
   

   import json
   with open('data.json', 'r') as file:
       data = json.load(file)
   

   import pickle
   data_bytes = pickle.dumps(data)
   

   import pickle
   with open('data.pkl', 'wb') as file:
       pickle.dump(data, file)
   

   import pickle
   data = pickle.loads(data_bytes)
   

   import pickle
   with open('data.pkl', 'rb') as file:
       data = pickle.load(file)
   

   from functools import reduce
   result = reduce(lambda x, y: x + y, [1, 2, 3, 4])
   print(result)  # Output: 10
   

   result = map(lambda x: x * 2, [1, 2, 3, 4])
   print(list(result))  # Output: [2, 4, 6, 8]
   

   result = filter(lambda x: x % 2 == 0, [1, 2, 3, 4])
   print(list(result))  # Output: [2, 4]
   

   from functools import partial
   def multiply(x, y):
       return x * y
   multiply_by_2 = partial(multiply, 2)
   print(multiply_by_2(4))  # Output: 8
   

   from functools import wraps
   def my_decorator(f):
       @wraps(f)
       def wrapped(*args, **kwargs):
           print("Calling decorated function")
           return f(*args, **kwargs)
       return wrapped

   @my_decorator
   def hello_world():
       print("Hello, World!")
   
   hello_world()
   print(hello_world.__name__)  # Output: hello_world
   

  import gc

  gc.collect()
  

  import weakref

  class MyClass:
      pass

  obj = MyClass()
  weak_obj = weakref.ref(obj)
  

import weakref

class MyClass:
    pass

obj = MyClass()
weak_obj = weakref.ref(obj)

print(weak_obj())  # Выведет объект
del obj
print(weak_obj())  # Выведет None, объект удалён

import asyncio

async def say_hello():
    await asyncio.sleep(1)
    print("Hello, asyncio!")

asyncio.run(say_hello())

import asyncio

async def main():
    print('Hello ...')
    await asyncio.sleep(1)
    print('... World!')

# Запуск корутины
asyncio.run(main())

import asyncio

async def my_async_function():
    print("Start")
    await asyncio.sleep(1)
    print("End")

asyncio.run(my_async_function())

import asyncio

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('World')

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close()

import asyncio

# Способ получения event loop
loop = asyncio.get_event_loop()

# Способы запуска корутины
async def my_coroutine():
    print("Hello, Coroutine")

# 1. Использовать await внутри другой корутины
async def main():
    await my_coroutine()

loop.run_until_complete(main())

# 2. Использовать asyncio.run
asyncio.run(my_coroutine())

# 3. Использовать loop.run_until_complete
loop.run_until_complete(my_coroutine())

# 4. Использовать loop.create_task или asyncio.ensure_future
task = loop.create_task(my_coroutine())
asyncio.ensure_future(my_coroutine())
loop.run_until_complete(task)

import asyncio

async def my_coroutine():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

# Запуск корутины
asyncio.run(my_coroutine())

import asyncio

async def main():
    await asyncio.sleep(1)
    print("Время вышло!")

asyncio.run(main())

import threading

def worker():
    print("Thread is working")

thread = threading.Thread(target=worker)
thread.start()
thread.join()

 
import multiprocessing
def worker():
    print("Worker process")
if __name__ == "__main__":
    process = multiprocessing.Process(target=worker)
    process.start()
    process.join()
   

import asyncio
async def say_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")
asyncio.run(say_hello())
   

import multiprocessing

def worker():
    print("Worker process")

if __name__ == "__main__":
    process = multiprocessing.Process(target=worker)
    process.start()
    process.join()

import gevent
from gevent import monkey

# Патчим стандартные функции для совместимости с gevent
monkey.patch_all()

def task1():
    for _ in range(3):
        print("Running task 1")
        gevent.sleep(1)

def task2():
    for _ in range(3):
        print("Running task 2")
        gevent.sleep(1)

# Запускаем гринлеты
gevent.joinall([
    gevent.spawn(task1),
    gevent.spawn(task2)
])

import logging

# Создание логгера
logger = logging.getLogger('example_logger')
logger.setLevel(logging.DEBUG)  # Уровень логгирования

# Создание обработчика для вывода логов на консоль
console_handler = logging.StreamHandler()

# Установка уровня обработчика
console_handler.setLevel(logging.DEBUG)

# Создание форматтера
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# Добавление форматтера к обработчику
console_handler.setFormatter(formatter)

# Добавление обработчика к логгеру
logger.addHandler(console_handler)

# Логирование примеров сообщений
logger.debug('Это сообщение отладки')
logger.info('Это информационное сообщение')
logger.warning('Это предупреждающее сообщение')
logger.error('Это сообщение об ошибке')
logger.critical('Это критическое сообщение')

a = 256
b = 256
print(a is b)  # True

x = 'hello'
y = 'hello'
print(x is y)  # True

class Meta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

class LoggingMixin:
    def log(self, message):
        print(f"Log: {message}")

class AppClass(LoggingMixin):
    def do_something(self):
        self.log("Doing something important!")

app = AppClass()
app.do_something()

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

dog = Dog()
print(dog.speak())

class MyClass:
    def __init__(self):
        self._value = 0

    def get_value(self):
        return self._value

    def set_value(self, value):
        if value >= 0:
            self._value = value
        else:
            raise ValueError("Value must be non-negative")

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        if new_value >= 0:
            self._value = new_value
        else:
            raise ValueError("Значение должно быть неотрицательным")

    @value.deleter
    def value(self):
        del self._value

# Использование
obj = MyClass(10)
print(obj.value)  # Получение значения
obj.value = 20    # Установка нового значения

<code>def greet(name: str) -> str:
    return "Hello, " + name
</code>

<code>
def greet(name: str, age: int) -> str:
    return f"Hello, {name}. You are {age} years old."
</code>

<code>
from typing import List, Optional

def process_items(items: List[int]) -> Optional[int]:
    if items:
        return items[0]
    return None
</code>

<code>from typing import List
def func(a: List[int]) -> None:
    pass
</code>

<code>from typing import Dict
def func(d: Dict[str, int]) -> None:
    pass
</code>

<code>from typing import Set
def func(s: Set[int]) -> None:
    pass
</code>

<code>from typing import Tuple
def func(t: Tuple[int, str]) -> None:
    pass
</code>

<code>from typing import Callable
def func(f: Callable[[int, str], bool]) -> None:
    pass
</code>

<code>from typing import TypeVar, Generic, List

T = TypeVar('T')

class MyList(Generic[T]):
    def __init__(self, items: List[T]):
        self.items = items
</code>