Xotira va samaradorlik

Nimalarni örganasiz
timeitvatime.perf_counterbilan tezlikni qanday ölçaşsys.getsizeofnimani körsatadi vatracemallocxotira qayerga ketayotganini qanday körsatadi- Havolalar soni (reference count),
gcvaweakrefobyektlar qaçon böşatilişini qanday hal qiladi cProfilevapstatsbilan sekin funksiyalarni qanday topiş- Qaysi tezlaştirişlar muhim (töplamlar,
join, örnatilgan funksiyalar,lru_cache) va qaçon optimallaştirmaslik kerak
Nega bu muhim
Samarqanddagi dökonning savdo hisoboti 40 daqiqa tayyorlanadi yoki veb-ilova asta-sekin xotirani yeb boradi. Odatda bunga bitta sekin qidiruv yoki ösib borayotgan röyxat aybdor. Pythonning örnatilgan vositalari öşa joyni topadi, şunda siz muhim kodni tuzatasiz, qolganini esa tuşunarli holda qoldirasiz.
Taxmin qilişdan oldin ölçang
timeit ifodani köp marta bajaradi va jami soniyalarni qaytaradi; timeit.repeat buni bir neça marta takrorlaydi, ular orasidagi eng kiçigi esa şovqini eng kam natija:
import timeit
ids = list(range(10_000))
ids_set = set(ids)
list_best = min(timeit.repeat("9_999 in ids", globals=globals(), number=1_000, repeat=5))
set_best = min(timeit.repeat("9_999 in ids_set", globals=globals(), number=1_000, repeat=5))
print("töplam tezroq:", set_best < list_best)töplam tezroq: TrueBitta noutbukda röyxat 0.103 soniya, töplam esa 0.00004 soniya oldi. Sizdagi sonlar boşqaça böladi, şuning uçun misol faqat taqqoslaşni çop etadi. Butun funksiyalarni vaqtlaş uçun time.perf_counter() (yuqori aniqlikdagi soat) Closure va dekoratorlar darsidagi kabi dekoratorga mos tuşadi:
import time
timings = {}
def timer(func):
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
timings[func.__name__] = time.perf_counter() - start
return result
return wrapper
@timer
def loop_total(numbers):
total = 0
for n in numbers:
total += n
return total
@timer
def builtin_total(numbers):
return sum(numbers)
numbers = list(range(1_000_000))
print(loop_total(numbers) == builtin_total(numbers))
print("eng tezi:", min(timings, key=timings.get))True
eng tezi: builtin_totalÖşa noutbukda timings taxminan 0.027 va 0.007 soniyani saqladi: sum kabi örnatilgan funksiyalar C tilida işlaydi.
Obyekt qança joy egallaydi?
sys.getsizeof(obj) faqat şu obyektning baytlarini qaytaradi. Röyxat elementlariga havolalarni saqlaydi, şuning uçun uning ölçamiga elementlarning özi kirmaydi:
import sys
short = [letter for letter in "abc"]
long = [letter * 10_000 for letter in "abc"]
print(sys.getsizeof(7), sys.getsizeof("Toşkent"))
print(sys.getsizeof(short), sys.getsizeof(long))
print(sys.getsizeof([n for n in range(1_000)]), sys.getsizeof(n for n in range(1_000)))28 72
88 88
8856 200Bu sonlar 64-bitli CPython 3.14 uçun; bu saytdagi muharrir 32-bitli yiğmada işlaydi, şuning uçun undagi sonlar kiçikroq. Muhimi qonuniyat: biri 30,000 belgiga işora qilsa ham, ikkala röyxat 88 bayt, generator (Iteratorlar va generatorlar) esa röyxat össa ham kiçikligiça qoladi.
Havolalar soni, gc va weakref
CPython har bir obyektga havolalarni sanaydi: unga işora qiladigan har bir nom, röyxat katakçasi yoki atribut. Son nolga yetganda obyekt darhol böşatiladi. sys.getrefcount bu sonni (vaqtinçalik havolalar bilan birga) körsatadi, şuning uçun farqlarni soliştiring:
import sys
prices = [15000, 8000]
before = sys.getrefcount(prices)
basket = prices
orders = {"tuşlik": prices}
print(sys.getrefcount(prices) - before)
del basket
print(sys.getrefcount(prices) - before)2
1Halqa (cycle) bölganda sanaş yordam bermaydi: bir-biriga işora qiladigan obyektlar heç qaçon nolga yetmaydi. Çiqindi yiğuvçi (garbage collector, gc) bunday guruhlarni vaqti-vaqti bilan topadi; gc.collect() uni hozir işga tuşiradi. Kuçsiz havola (weak reference) obyektni tirik saqlamasdan kuzatadi:
import gc
import weakref
class Customer:
def __init__(self, name):
self.name = name
self.friend = None
gc.disable() # faqat biz söraganda yiğadi
aziza = Customer("Aziza")
bobur = Customer("Bobur")
aziza.friend = bobur
bobur.friend = aziza # halqa
watch = weakref.ref(aziza) # watch() obyektni yoki None ni beradi
del aziza, bobur
print("del dan keyin tirik:", watch() is not None)
print("gc çiqindi topdi:", gc.collect() > 0)
print("collect dan keyin tirik:", watch() is not None)
gc.enable()del dan keyin tirik: True
gc çiqindi topdi: True
collect dan keyin tirik: FalseKuçsiz havolalar xavfsiz keşlar ham yaratadi: weakref.WeakValueDictionary yozuvning qiymatidan boşqa joyda foydalanilmay qolişi bilanoq uni öçiradi.
Xotira qayerga ketayotganini topiş: tracemalloc
tracemalloc har bir xotira ajratilişini va uni bajargan qatorni yozib boradi:
import tracemalloc
def load_orders():
return [{"id": n, "city": "Toşkent", "total": n * 1000} for n in range(50_000)]
def load_names():
return [f"mijoz-{n}" for n in range(50_000)]
tracemalloc.start()
orders = load_orders()
names = load_names()
snapshot = tracemalloc.take_snapshot()
tracemalloc.stop()
for stat in snapshot.statistics("lineno")[:2]:
frame = stat.traceback[0]
print(f"{frame.lineno}-qator: {stat.size / 1_000_000:.1f} MB")4-qator: 12.8 MB
7-qator: 3.0 MBQarab çiqiş kerak bölgan joy - luğatlar yaratiladigan 4-qator. Köplab kiçik obyektlar uçun Python maʼlumot modeli darsidagi __slots__ yordam beradi; get_traced_memory() joriy va eng yuqori bayt sonlarini qaytaradi:
import tracemalloc
class Point:
def __init__(self, x, y):
self.x, self.y = x, y
class SlotPoint:
__slots__ = ("x", "y")
def __init__(self, x, y):
self.x, self.y = x, y
for cls in (Point, SlotPoint):
tracemalloc.start()
points = [cls(n, n) for n in range(100_000)]
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"{cls.__name__}: har bir nuqtaga {current // 100_000} bayt")Point: har bir nuqtaga 127 bayt
SlotPoint: har bir nuqtaga 87 bayt(64-bitli CPython, röyxat va butun sonlar bilan birga.) Uçdan bir qism tejaş millionlab obyektlarda sezilarli bölib qoladi.
Sekin kodni topiş: cProfile
Profilçi (profiler) har bir funksiya neça marta va qança vaqt işlaganini yozib boradi; pstats natijalarni öqiydi:
import cProfile
import pstats
def parse(line):
city, amount = line.split(",")
return city, int(amount)
def total_by_city(lines):
totals = {}
for line in lines:
city, amount = parse(line)
totals[city] = totals.get(city, 0) + amount
return totals
lines = ["Toşkent,15000", "Samarqand,8000", "Buxoro,12000"] * 20_000
with cProfile.Profile() as profiler:
total_by_city(lines)
stats = pstats.Stats(profiler).strip_dirs()
calls = stats.get_stats_profile().func_profiles
print("parse", calls["parse"].ncalls, "marta işladi")parse 60000 marta işladiTöliq jadval uçun stats.sort_stats("cumulative").print_stats(2) ni çaqiring. Bir işga tuşirişda u quyidagini çop etdi (sizdagi vaqtlar boşqaça böladi):
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.028 0.028 0.075 0.075 sales.py:8(total_by_city)
60000 0.026 0.000 0.038 0.000 sales.py:4(parse)cumtime çaqirilgan funksiyalarni ham öz içiga oladi, tottime esa yöq. Öz kodingizdagi eng katta cumtime dan boşlang.
Keng tarqalgan tezlaştirişlar
Profil qizğin joyni (hot spot) topgaç, köp hollarda quyidagi tuzatişlar yetarli:
- Töğri maʼlumot tuzilmasi: töplamda
intöplam qança katta bölmasin tez işlaydi; röyxat esa har bir elementni tekşiradi. - Siklda
text += partörniga"".join(parts). - Qölda yozilgan sikllar örniga örnatilgan funksiyalar va comprehensionlar.
- Juda qizğin sikllarda lokal nomlar:
sqrt = math.sqrthar qadamda bitta qidiruvni tejaydi (kiçik yutuq). - Takroriy işni
functools.lru_cachebilan keşlaş:
from functools import lru_cache
@lru_cache(maxsize=None)
def route_count(rows, cols):
if rows == 1 or cols == 1:
return 1
return route_count(rows - 1, cols) + route_count(rows, cols - 1)
print(route_count(16, 16))
print(route_count.cache_info())155117520
CacheInfo(hits=196, misses=255, maxsize=None, currsize=255)Keşsiz bu taxminan 310 million çaqiruv qiladi; keş bilan esa 451 ta.
Qaçon optimallaştirmaslik kerak: kod bir marta işlasa, tez tugasa yoki profilning yuqori qismida bölmasa. Tuşunarli kod heç kimga kerak bölmagan tez koddan yaxşiroq.
Özingiz sinab köring
n ni 100,000 ga özgartiring va farq qanday öşişini kuzating.
Köp uçraydigan xatolar
1. Har xil hajmdagi işni soliştiriş
import timeit
loop = timeit.timeit("[n * 2 for n in range(1000)]", number=10_000)
builtin = timeit.timeit("list(map(lambda n: n * 2, range(1000)))", number=100)
print(loop, builtin)0.3371560389999786 0.0063662349999731305Birinçisi 10,000 marta, ikkinçisi 100 marta işladi, şuning uçun map 50 barobar tezroq körinadi; bir xil number bilan esa u aslida sekinroq. Tuzatiş: bir xil number, bir xil maʼlumot va min(timeit.repeat(...)) dan foydalaning.
2. time.time() bilan bir marta vaqtlaş
import time
start = time.time()
total = sum(range(10_000))
print(time.time() - start)0.00016045570373535156Bitta kiçik işga tuşiriş asosan şovqin, time.time() esa tizim soati bilan birga sakraşi mumkin. Tuzatiş: kiçik kod bölaklari uçun timeit, uzunroq vazifalar uçun time.perf_counter() dan foydalaning.
3. Tasodifiy havola maʼlumotni tirik saqlaydi
import weakref
class Report:
def __init__(self, rows):
self.rows = rows
def row_count(report, seen=[]): # Yomon: bu röyxat funksiya qança yaşasa, şunça yaşaydi
seen.append(report)
return len(report.rows)
report = Report(list(range(1_000_000)))
alive = weakref.ref(report)
print(row_count(report))
del report
print("hali ham xotirada:", alive() is not None)1000000
hali ham xotirada: TrueStandart qiymat sifatidagi röyxat unga uzatilgan har bir hisobotni saqlab qoladi; global özgaruvçilar va çeklanmagan keşlar ham şunday qilişi mumkin. Tuzatiş: kerak bölmagan narsani saqlamang.
4. Bir marta işlaydigan kodni optimallaştiriş
cities = "Toşkent,Samarqand,Buxoro".split(",")
# Yomon: bir marta işlaydigan koddagi tuşunarsiz "tezlik hiylasi"
lookup = dict(map(reversed, enumerate(cities)))
# Yaxşi: ravşan; farq mikrosoniyalarda
clear = {city: i for i, city in enumerate(cities)}
print(lookup == clear, clear)True {'Toşkent': 0, 'Samarqand': 1, 'Buxoro': 2}Tuzatiş: faqat profil sekin deb körsatgan joyni optimallaştiring.
Maşqlar
1. Sayoz va çuqur ölçam
deep_size(items) ni yozing: röyxatning sys.getsizeof i va uning elementlari ölçamlari yiğindisi. words = [word * 1000 for word in ["palov", "somsa"]] va short = [word[0] for word in words] uçun deep_size(words) > sys.getsizeof(words) ekanini, keyin sys.getsizeof(words) == sys.getsizeof(short) ekanini çop eting.
Yeçim
import sys
def deep_size(items):
return sys.getsizeof(items) + sum(sys.getsizeof(item) for item in items)
words = [word * 1000 for word in ["palov", "somsa"]]
short = [word[0] for word in words]
print(deep_size(words) > sys.getsizeof(words))
print(sys.getsizeof(words) == sys.getsizeof(short))True
True2. Obyekt yöqolişini kuzatiş
Order yarating, unga weakref.finalize(order, print, "42-buyurtma böşatildi") ni biriktiring, öçirilmoqda... ni çop eting, obyektni öçiring, keyin tayyor ni çop eting.
Yeçim
import weakref
class Order:
pass
order = Order()
weakref.finalize(order, print, "42-buyurtma böşatildi")
print("öçirilmoqda...")
del order
print("tayyor")öçirilmoqda...
42-buyurtma böşatildi
tayyor3. Haqiqiy işni sanang
delivery_cost(city) {"Toşkent": 20000, "Buxoro": 35000, "Nukus": 50000} dan narxni topadi va global calls hisoblagiçiga bir qöşadi (buni sekin maʼlumotlar bazasi sörovi deb tasavvur qiling). Uni @lru_cache(maxsize=None) bilan keşlang, keyin Toşkent, Buxoro, Toşkent, Nukus, Buxoro, Toşkentga buyurtmalar uçun jami narxni, calls ni va delivery_cost.cache_info() ni çop eting.
Yeçim
from functools import lru_cache
PRICES = {"Toşkent": 20000, "Buxoro": 35000, "Nukus": 50000}
calls = 0
@lru_cache(maxsize=None)
def delivery_cost(city):
global calls
calls += 1 # sekin qism faqat keşda topilmaganda işlaydi
return PRICES[city]
orders = ["Toşkent", "Buxoro", "Toşkent", "Nukus", "Buxoro", "Toşkent"]
print(sum(delivery_cost(city) for city in orders))
print(calls)
print(delivery_cost.cache_info())180000
3
CacheInfo(hits=3, misses=3, maxsize=None, currsize=3)4. Töğri tuzilmani tanlang
Taqiqlangan spam, arzon va oltin sözlarini (ular töplamda saqlanadi) *** bilan almaştiradigan clean(message) ni yozing. "hoziroq arzon oltin oling", "Toşkentdan salom" va "bu yerda arzon spam" ni tozalab çop eting.
Yeçim
banned = {"spam", "arzon", "oltin"}
def clean(message):
return " ".join("***" if word in banned else word for word in message.split())
for message in ["hoziroq arzon oltin oling", "Toşkentdan salom", "bu yerda arzon spam"]:
print(clean(message))hoziroq *** *** oling
Toşkentdan salom
bu yerda *** ***5. Profillang, tuzating, yana profillang
is_prime_slow(n) 2 dan n - 1 gaça har bir d uçun divides(d, n) ni çaqiradi. d * d > n bölişi bilan töxtaydigan is_prime_fast(n) ni yozing. Har biri bilan 2 dan 2,999 gaça tub sonlarni sanaşni profillang va funksiya nomini, tub sonlar sonini hamda divides neça marta işlaganini çop eting.
Yeçim
import cProfile
import pstats
def divides(d, n):
return n % d == 0
def is_prime_slow(n):
for d in range(2, n):
if divides(d, n):
return False
return True
def is_prime_fast(n):
d = 2
while d * d <= n:
if divides(d, n):
return False
d += 1
return True
for is_prime in (is_prime_slow, is_prime_fast):
with cProfile.Profile() as profiler:
count = sum(1 for n in range(2, 3_000) if is_prime(n))
calls = pstats.Stats(profiler).get_stats_profile().func_profiles["divides"].ncalls
print(is_prime.__name__, count, calls)is_prime_slow 430 601875
is_prime_fast 430 23091Çaqiruvlar soni kompyuteringiz tezligiga boğliq emas.
Xulosa
- Avval ölçang: kod bölaklari uçun
min(timeit.repeat(...)), funksiyalar uçun@timeriçidatime.perf_counter(). sys.getsizeofsayoz ölçaydi;tracemallocqaysi qatorlar eng köp xotira ajratişini körsatadi.- Havolalar soni nolga yetganda obyekt öladi;
gchalqalarni yiğadi;weakrefobyektni tirik saqlamaydi. cumulativeböyiça saralanganpstatsbilancProfilevaqt qayerga ketayotganini körsatadi.- Töplamlar,
join, örnatilgan funksiyalar,lru_cacheva__slots__köp qizğin joylarni tuzatadi; bir marta işlaydigan kodga tegmang.