🐍⚙️ 10 способов оптимизации Python-кода

        import struct
import random
import sys

nums = [random.randint(0, 1000000) for _ in range(5000)]
packed_nums = struct.pack(f'{len(nums)}i', *nums)
original_size_nums = sys.getsizeof(nums)
packed_size_nums = sys.getsizeof(packed_nums)
efficiency = (1 - packed_size_nums / original_size_nums) * 100

print(f'Исходный размер: {original_size_nums} байт')
print(f'Упакованный размер: {packed_size_nums} байт')
print(f'Эффективность сжатия: {efficiency:.2f}%')

unpacked_nums = struct.unpack(f'{len(nums)}i', packed_nums)

for i in range(0, 5000, 100):
    print(f"Проверяем число с индексом {i}:")
    print(f"Исходное число: {nums[i]}, распакованное число: {unpacked_nums[i]}")
    assert nums[i] == unpacked_nums[i], f"Несовпадение чисел по индексу {i}"
print("Все числа совпали")


    

        Исходный размер: 41880 байт
Упакованный размер: 20033 байт
Эффективность сжатия: 52.17%
Проверяем число с индексом 0:
Исходное число: 538873, распакованное число: 538873
Проверяем число с индексом 100:
Исходное число: 918169, распакованное число: 918169
Проверяем число с индексом 200:
Исходное число: 663463, распакованное число: 663463
Проверяем число с индексом 300:
Исходное число: 335298, распакованное число: 335298
Проверяем число с индексом 400:
Исходное число: 103470, распакованное число: 103470
Проверяем число с индексом 500:
Исходное число: 537139, распакованное число: 537139
Проверяем число с индексом 600:
Исходное число: 816242, распакованное число: 816242
Проверяем число с индексом 700:
Исходное число: 736703, распакованное число: 736703
Проверяем число с индексом 800:
Исходное число: 134686, распакованное число: 134686
Проверяем число с индексом 900:
Исходное число: 198001, распакованное число: 198001
Проверяем число с индексом 1000:
Исходное число: 833857, распакованное число: 833857
Проверяем число с индексом 1100:
Исходное число: 230153, распакованное число: 230153
Проверяем число с индексом 1200:
Исходное число: 728830, распакованное число: 728830
Проверяем число с индексом 1300:
Исходное число: 641456, распакованное число: 641456
Проверяем число с индексом 1400:
Исходное число: 794241, распакованное число: 794241
Проверяем число с индексом 1500:
Исходное число: 389231, распакованное число: 389231
Проверяем число с индексом 1600:
Исходное число: 455378, распакованное число: 455378
Проверяем число с индексом 1700:
Исходное число: 876660, распакованное число: 876660
Проверяем число с индексом 1800:
Исходное число: 812566, распакованное число: 812566
Проверяем число с индексом 1900:
Исходное число: 468887, распакованное число: 468887
Проверяем число с индексом 2000:
Исходное число: 769358, распакованное число: 769358
Проверяем число с индексом 2100:
Исходное число: 8201, распакованное число: 8201
Проверяем число с индексом 2200:
Исходное число: 977281, распакованное число: 977281
Проверяем число с индексом 2300:
Исходное число: 629243, распакованное число: 629243
Проверяем число с индексом 2400:
Исходное число: 117519, распакованное число: 117519
Проверяем число с индексом 2500:
Исходное число: 229750, распакованное число: 229750
Проверяем число с индексом 2600:
Исходное число: 833149, распакованное число: 833149
Проверяем число с индексом 2700:
Исходное число: 764713, распакованное число: 764713
Проверяем число с индексом 2800:
Исходное число: 174090, распакованное число: 174090
Проверяем число с индексом 2900:
Исходное число: 95317, распакованное число: 95317
Проверяем число с индексом 3000:
Исходное число: 241478, распакованное число: 241478
Проверяем число с индексом 3100:
Исходное число: 197858, распакованное число: 197858
Проверяем число с индексом 3200:
Исходное число: 152379, распакованное число: 152379
Проверяем число с индексом 3300:
Исходное число: 147324, распакованное число: 147324
Проверяем число с индексом 3400:
Исходное число: 561581, распакованное число: 561581
Проверяем число с индексом 3500:
Исходное число: 97425, распакованное число: 97425
Проверяем число с индексом 3600:
Исходное число: 92997, распакованное число: 92997
Проверяем число с индексом 3700:
Исходное число: 106960, распакованное число: 106960
Проверяем число с индексом 3800:
Исходное число: 197652, распакованное число: 197652
Проверяем число с индексом 3900:
Исходное число: 380352, распакованное число: 380352
Проверяем число с индексом 4000:
Исходное число: 732233, распакованное число: 732233
Проверяем число с индексом 4100:
Исходное число: 274363, распакованное число: 274363
Проверяем число с индексом 4200:
Исходное число: 131550, распакованное число: 131550
Проверяем число с индексом 4300:
Исходное число: 628213, распакованное число: 628213
Проверяем число с индексом 4400:
Исходное число: 403623, распакованное число: 403623
Проверяем число с индексом 4500:
Исходное число: 583847, распакованное число: 583847
Проверяем число с индексом 4600:
Исходное число: 697159, распакованное число: 697159
Проверяем число с индексом 4700:
Исходное число: 699888, распакованное число: 699888
Проверяем число с индексом 4800:
Исходное число: 242131, распакованное число: 242131
Проверяем число с индексом 4900:
Исходное число: 463454, распакованное число: 463454
Все числа совпали


    

        import mmap

def print_specific_lines(filename, lines_to_print):
    with open(filename, "r+b") as f:
        mmapped_file = mmap.mmap(f.fileno(), 0)        
        lines = mmapped_file.read().decode('utf-8').splitlines()
        
        for i in range(99, len(lines), 100):
            if len(lines[i]) != 0:
                print(f"Строка {i + 1}: {lines[i]}")
        

        for i in range(499, len(lines), 500):
            if len(lines[i]) != 0:
                print(f"Строка {i + 1}: {lines[i]}")
        
        mmapped_file.close()

print_specific_lines("alice.txt", [100, 500])


    

        Строка 400: being drowned in my own tears! That _will_ be a queer thing, to be
Строка 500: “Ahem!” said the Mouse with an important air, “are you all ready? This
Строка 700: little door, had vanished completely.
Строка 1000: good reason, and as the Caterpillar seemed to be in a _very_ unpleasant
Строка 1100: rearing itself upright as it spoke (it was exactly three inches high).
Строка 1200: “I—I’m a little girl,” said Alice, rather doubtfully, as she remembered
Строка 1500: a Hatter: and in _that_ direction,” waving the other paw, “lives a
Строка 1600: “Then it wasn’t very civil of you to offer it,” said Alice angrily.
Строка 2000: their faces, and the pattern on their backs was the same as the rest of
Строка 2200: the question, and they repeated their arguments to her, though, as they
Строка 2400: she was out of sight: then it chuckled. “What fun!” said the Gryphon,
Строка 2600: “Back to land again, and that’s all the first figure,” said the Mock
Строка 2700: “They were obliged to have him with them,” the Mock Turtle said: “no
Строка 2900: and she could even make out that one of them didn’t know how to spell
Строка 3000: “I’m a poor man, your Majesty,” the Hatter began, in a trembling voice,
Строка 3200: “What’s in it?” said the Queen.
Строка 3300: “All right, so far,” said the King, and he went on muttering over the
Строка 3400: their simple joys, remembering her own child-life, and the happy summer
Строка 3500: 1.E.1. The following sentence, with active links to, or other
Строка 3700: Section 4. Information about Donations to the Project Gutenberg
Строка 500: “Ahem!” said the Mouse with an important air, “are you all ready? This
Строка 1000: good reason, and as the Caterpillar seemed to be in a _very_ unpleasant
Строка 1500: a Hatter: and in _that_ direction,” waving the other paw, “lives a
Строка 2000: their faces, and the pattern on their backs was the same as the rest of
Строка 3000: “I’m a poor man, your Majesty,” the Hatter began, in a trembling voice,
Строка 3500: 1.E.1. The following sentence, with active links to, or other

    

        import array
import time
import sys

arr = array.array('i', range(1000000))
lst = list(range(1000000))

# Сравнение размера в памяти
print(f"Размер array.array: {sys.getsizeof(arr)} байт")
print(f"Размер list: {sys.getsizeof(lst)} байт")

# Сравнение скорости доступа
def access_test(container):
    start = time.time()
    for _ in range(1000000):
        _ = container[500000]
    return time.time() - start

print(f"Время доступа для array.array: {access_test(arr):.6f} сек")
print(f"Время доступа для list: {access_test(lst):.6f} сек")

# Сравнение скорости числовых операций
def numeric_operation_test(container):
    start = time.time()
    for i in range(len(container)):
        container[i] *= 2
    return time.time() - start

arr_copy = array.array('i', arr)
lst_copy = list(lst)

print(f"Время числовых операций для array.array: {numeric_operation_test(arr_copy):.6f} сек")
print(f"Время числовых операций для list: {numeric_operation_test(lst_copy):.6f} сек")

# Сериализация
import pickle

start = time.time()
pickle.dumps(arr)
print(f"Время сериализации array.array: {time.time() - start:.6f} сек")

start = time.time()
pickle.dumps(lst)
print(f"Время сериализации list: {time.time() - start:.6f} сек")
    

        Размер array.array: 4091948 байт
Размер list: 8000056 байт
Время доступа для array.array: 0.230873 сек
Время доступа для list: 0.112998 сек
Время числовых операций для array.array: 0.622823 сек
Время числовых операций для list: 0.385629 сек
Время сериализации array.array: 0.008033 сек
Время сериализации list: 0.030163 сек

    

        import string
import logging

# Настройка логирования
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Внутренняя функция для очистки строки от знаков препинания
def _clean_string(input_string):
    translator = str.maketrans('', '', string.punctuation)
    cleaned_string = input_string.translate(translator)
    return cleaned_string

def count_characters(input_string):
    logger.info(f"Вызвана функция count_characters с аргументом: {input_string}")
    try:
        cleaned_string = _clean_string(input_string)
        result = len(cleaned_string)
        logger.info(f"Функция count_characters вернула результат: {result}")
        return result
    except Exception as e:
        logger.error(f"Ошибка в функции count_characters: {e}")
        return 0  

def count_words(input_string):
    logger.info(f"Вызвана функция count_words с аргументом: {input_string}")
    try:
        cleaned_string = _clean_string(input_string)
        result = len(cleaned_string.split())
        logger.info(f"Функция count_words вернула результат: {result}")
        return result
    except Exception as e:
        logger.error(f"Ошибка в функции count_words: {e}")
        return 0  

def reverse_string(input_string):
    logger.info(f"Вызвана функция reverse_string с аргументом: {input_string}")
    try:
        cleaned_string = _clean_string(input_string)
        result = cleaned_string[::-1]
        logger.info(f"Функция reverse_string вернула результат: {result}")
        return result
    except Exception as e:
        logger.error(f"Ошибка в функции reverse_string: {e}")
        return ""  


input_data = input()
print("Оригинальная строка:", input_data)
print("Количество символов:", count_characters(input_data))
print("Количество слов:", count_words(input_data))
print("Строка в обратном порядке:", reverse_string(input_data))


    

        Оригинальная строка: Привет, мир!!! Это - текстовая строка (для демонстрации).
2024-08-28 21:12:09,353 - INFO - Вызвана функция count_characters с аргументом: Привет, мир!!! Это - текстовая строка (для демонстрации).
2024-08-28 21:12:09,353 - INFO - Функция count_characters вернула результат: 49
Количество символов: 49
2024-08-28 21:12:09,353 - INFO - Вызвана функция count_words с аргументом: Привет, мир!!! Это - текстовая строка (для демонстрации).
2024-08-28 21:12:09,353 - INFO - Функция count_words вернула результат: 7
Количество слов: 7
2024-08-28 21:12:09,353 - INFO - Вызвана функция reverse_string с аргументом: Привет, мир!!! Это - текстовая строка (для демонстрации).
2024-08-28 21:12:09,353 - INFO - Функция reverse_string вернула результат: иицартсномед ялд акортс яавотскет  отЭ рим тевирП
Строка в обратном порядке: иицартсномед ялд акортс яавотскет  отЭ рим тевирП
    

        import time
from functools import lru_cache, wraps
import random

# Декоратор для измерения времени выполнения
def measure_time(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} выполнена за {end - start:.2f} сек")
        return result
    return wrapper

# Имитация внешнего API с задержкой
def slow_api_request(user_id):
    time.sleep(2)
    return {
        "id": user_id,
        "name": f"User {user_id}",
        "last_login": time.time(),
        "score": random.randint(1, 100)
    }

# Функция без кэширования
@measure_time
def get_user_data(user_id):
    print(f"Запрос данных для пользователя {user_id}")
    return slow_api_request(user_id)

# Функция с кэшированием
@measure_time
@lru_cache(maxsize=100)
def get_user_data_cached(user_id):
    print(f"Запрос данных для пользователя {user_id}")
    return slow_api_request(user_id)

def run_test():
    user_ids = [1, 2, 3, 1, 2, 1, 1, 3]  
    print("Без кэширования:")
    for user_id in user_ids:
        get_user_data(user_id)

    print("\nС кэшированием:")
    for user_id in user_ids:
        get_user_data_cached(user_id)

run_test()
    

        Без кэширования:
Запрос данных для пользователя 1
get_user_data выполнена за 2.00 сек
Запрос данных для пользователя 2
get_user_data выполнена за 2.00 сек
Запрос данных для пользователя 3
get_user_data выполнена за 2.00 сек
Запрос данных для пользователя 1
get_user_data выполнена за 2.00 сек
Запрос данных для пользователя 2
get_user_data выполнена за 2.00 сек
Запрос данных для пользователя 1
get_user_data выполнена за 2.00 сек
Запрос данных для пользователя 1
get_user_data выполнена за 2.00 сек
Запрос данных для пользователя 3
get_user_data выполнена за 2.00 сек

С кэшированием:
Запрос данных для пользователя 1
get_user_data_cached выполнена за 2.00 сек
Запрос данных для пользователя 2
get_user_data_cached выполнена за 2.00 сек
Запрос данных для пользователя 3
get_user_data_cached выполнена за 2.00 сек
get_user_data_cached выполнена за 0.00 сек
get_user_data_cached выполнена за 0.00 сек
get_user_data_cached выполнена за 0.00 сек
get_user_data_cached выполнена за 0.00 сек
get_user_data_cached выполнена за 0.00 сек
    

        import numpy as np
import timeit

def generate_random_data(size):
    return np.random.rand(size)

# Функция для вычисления суммы квадратов с помощью NumPy
def sum_squares_numpy(arr):
    return np.sum(arr**2)

# Функция для вычисления суммы квадратов с помощью обычного Python-цикла
def sum_squares_python(arr):
    result = 0
    for num in arr:
        result += num**2
    return result

def test_performance():
    size = 5000000
    arr = generate_random_data(size)
    print(f"\nВычисление для массива размером {size}:")
    
    # Вычисляем время выполнения для NumPy
    start_time = timeit.default_timer()
    sum_squares_numpy(arr)
    numpy_time = timeit.default_timer() - start_time
    
    # Вычисляем время выполнения для Python
    start_time = timeit.default_timer()
    sum_squares_python(arr)
    python_time = timeit.default_timer() - start_time
    
    print(f"\nВремя выполнения с NumPy: {numpy_time:.6f} секунд")
    print(f"Время выполнения с Python: {python_time:.6f} секунд")

test_performance()
    

        Вычисление для массива размером 5000000:

Время выполнения с NumPy: 0.085850 секунд
Время выполнения с Python: 1.128655 секунд
    

        def is_leap_year(year):
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
    

        import os
import psutil
import gc

def memory_usage():
    process = psutil.Process(os.getpid())
    return process.memory_info().rss / (1024 * 1024)  # в МБ

print(f"Использование памяти до: {memory_usage():.1f} МБ")

large_data = [i for i in range(10000000)]
print(f"Использование памяти после создания: {memory_usage():.1f} МБ")

del large_data
gc.collect()

print(f"Использование памяти после удаления: {memory_usage():.1f} МБ")
    

        Использование памяти до: 20.3 МБ
Использование памяти после создания: 402.8 МБ
Использование памяти после удаления: 21.5 МБ
    

        try:
    result = 10 / 0
except ZeroDivisionError:
    print("Err: Div/0")
    

        import random
import time
import numpy as np

def generate_matrix(size):
    return [[random.randint(-100, 100) for _ in range(size)] for _ in range(size)]

def matrix_operations_with_list_comprehension(A, B):
    size = len(A)
    C = [[A[i][j] * B[j][i] for j in range(size)] for i in range(size)]
    
    D = [[sum(C[i][k] * B[k][j] for k in range(size)) for j in range(size)] 
         for i in range(size)]
    
    E = [[D[i][j] + D[j][i] for j in range(size)] for i in range(size)]
    
    return E

def matrix_operations_with_loops(A, B):
    size = len(A)
    C = [[0] * size for _ in range(size)]
    D = [[0] * size for _ in range(size)]
    E = [[0] * size for _ in range(size)]
    
    for i in range(size):
        for j in range(size):
            C[i][j] = A[i][j] * B[j][i]
    
    for i in range(size):
        for j in range(size):
            D[i][j] = 0
            for k in range(size):
                D[i][j] += C[i][k] * B[k][j]
    
    for i in range(size):
        for j in range(size):
            E[i][j] = D[i][j] + D[j][i]
    
    return E

def matrix_operations_with_numpy(A, B):
    A = np.array(A)
    B = np.array(B)
    C = A * B.T
    D = C @ B
    E = D + D.T
    return E.tolist()

def test_performance():
    size = 400
    print(f"\nВычисления для матриц размером {size}x{size}:")

    A = generate_matrix(size)
    B = generate_matrix(size)

    start_time = time.time()
    E_loop = matrix_operations_with_loops(A, B)
    loops_time = time.time() - start_time

    start_time = time.time()
    E_list = matrix_operations_with_list_comprehension(A, B)
    list_time = time.time() - start_time
    
    start_time = time.time()
    E_numpy = matrix_operations_with_numpy(A, B)
    numpy_time = time.time() - start_time

    print(f"\nВремя выполнения с обычными циклами: {loops_time:.6f} секунд")
    print(f"Время выполнения со списковыми включениями: {list_time:.6f} секунд")
    print(f"Время выполнения с NumPy: {numpy_time:.6f} секунд")

test_performance()

    

        Вычисления для матриц размером 400x400:

Время выполнения с обычными циклами: 18.304441 секунд
Время выполнения со списковыми включениями: 15.638463 секунд
Время выполнения с NumPy: 0.134936 секунд