కలెక్షన్స్ మాడ్యూల్ & అడ్వాన్స్‌డ్ డేటా స్ట్రక్చర్స్

1 స్టాండర్డ్ డేటా స్ట్రక్చర్స్ సరిపోవా? (Why Collections Module?)

పైథాన్ అంతర్నిర్మిత ప్రాథమిక డేటా రకాలు అద్భుతమైనవే అయినప్పటికీ, పెద్ద స్థాయి ఎంటర్‌ప్రైజ్ అప్లికేషన్లలో కొన్ని నిర్దిష్టమైన పరిమితులను కలిగి ఉంటాయి:

• సాధారణ లిస్ట్‌ల క్యూ సమస్య: లిస్ట్ చివరన డేటాను జోడించడం (append()) వేగవంతమే (O(1)), కానీ లిస్ట్ మొదటి భాగం నుండి ఎలిమెంట్‌ను తీసివేయడం (pop(0)) మొత్తం లిస్ట్‌ను షిఫ్ట్ చేయాల్సి రావడం వల్ల O(N) సమయం పడుతుంది. ఇది వేలకొద్దీ రిక్వెస్ట్‌లు వచ్చే సర్వర్లలో తీవ్రమైన జాప్యానికి (Lag) కారణమవుతుంది.
• డిక్షనరీల్లో KeyError గందరగోళం: గ్రూపింగ్ చేసేటప్పుడు కీ ఉందో లేదో ప్రతిసారీ if key not in d: d[key] = [] అని తనిఖీ చేయాల్సి వస్తుంది.
• ప్రాధాన్యత ఆధారిత టాస్క్ షెడ్యూలింగ్ (Priority Queuing): సాధారణ లిస్ట్‌ను ప్రతిసారీ సార్ట్ చేయడం (list.sort() - O(N log N)) అత్యంత ఖరీదైన పని. మనకు నిరంతరం అత్యల్ప లేదా అత్యున్నత విలువను O(log N) వేగంతో అందించే బైనరీ హీప్ (Binary Heap) అవసరం.

ఈ లోపాలను అధిగమించడానికి పైథాన్ స్టాండర్డ్ లైబ్రరీ collections మరియు heapq మాడ్యూల్స్‌ను ప్రత్యేకంగా అందించింది.

2 collections.Counter — ఫ్రీక్వెన్సీ ఎనాలసిస్ సూపర్ పవర్

Counter అనేది డిక్షనరీ యొక్క సబ్‌క్లాస్. ఇది ఒక ఇటరబుల్ (లిస్ట్, స్ట్రింగ్, టుపుల్) లోని అంశాలు ఎన్నిసార్లు పునరావృతమయ్యాయో (Frequency) స్వయంచాలకంగా లెక్కించి భద్రపరుస్తుంది.

Counter యొక్క అగ్రశ్రేణి ఫీచర్లు:

• జీరో KeyError ప్రొటెక్షన్: సాధారణ డిక్షనరీలో లేని కీని అడిగితే KeyError వస్తుంది, కానీ Counter లో లేని కీని అడిగితే ఎటువంటి ఎర్రర్ లేకుండా శుభ్రంగా 0 రిటర్న్ చేస్తుంది!
• most_common(N): అత్యధిక ఫ్రీక్వెన్సీ కలిగిన టాప్ N ఎలిమెంట్లను (item, count) టుపుల్స్ రూపంలో అత్యంత వేగంగా అందిస్తుంది.
• మల్టీసెట్ అరిథ్‌మెటిక్ (Multiset Operators): రెండు కౌంటర్లను నేరుగా కలపవచ్చు (c1 + c2), తీసివేయవచ్చు (c1 - c2), లేదా ఉమ్మడి కనిష్టాలను (c1 & c2) మరియు గరిష్టాలను (c1 | c2) లెక్కించవచ్చు!

3 కోడ్ డెమో 1: టెక్స్ట్ మైనింగ్ & వర్డ్ ఫ్రీక్వెన్సీ విశ్లేషణ

సోషల్ మీడియా హ్యాష్‌ట్యాగ్‌లు లేదా కస్టమర్ రివ్యూల నుండి అత్యంత ట్రెండింగ్ కీలక పదాలను Counter ద్వారా ఎలా విశ్లేషించవచ్చో క్రింది కోడ్‌లో చూడండి:

# collections.Counter డెమో
from collections import Counter

# సోషల్ మీడియా కామెంట్ల నుండి సేకరించిన పదాలు
review_words = [
    "python", "fast", "clean", "python", "ai", "ml", "python",
    "awesome", "data", "ai", "fast", "python", "future", "ai"
]

word_counts = Counter(review_words)

print("=== 1. ఫ్రీక్వెన్సీ సమ్మరీ ===")
for word, count in word_counts.items():
    print(f"పదం : {word:<12} పునరావృతం : {count} సార్లు")

# టాప్ 2 ట్రెండింగ్ పదాలు
print("\n=== 2. మోస్ట్ కామన్ ఎలిమెంట్స్ (Top 2) ===")
top_2 = word_counts.most_common(2)
for rank, (word, freq) in enumerate(top_2, start=1):
    print(f"ర్యాంక్ {rank}: '{word}' ({freq} సార్లు వచ్చింది)")

# లేని కీని చదవడం (నో KeyError!)
print(f"\n'blockchain' కౌంట్ : {word_counts['blockchain']} (స్వయంచాలకంగా 0!)")

4 collections.defaultdict — జీరో KeyError ఆర్కిటెక్చర్

defaultdict అనేది డిక్షనరీలోని కీలు లేనప్పుడు వచ్చే KeyError ను శాశ్వతంగా నిర్మూలించే ఒక అద్భుతమైన సాధనం. డిక్షనరీని సృష్టించేటప్పుడే దానికి ఒక ఫ్యాక్టరీ ఫంక్షన్ (Default Factory) ను అందిస్తాము.

• defaultdict(list): కొత్త కీ రాగానే స్వయంచాలకంగా ఒక ఖాళీ లిస్ట్ [] ను సృష్టిస్తుంది. గ్రూపింగ్ చేయడానికి ఇది ఉత్తమమైన మార్గం.
• defaultdict(int): కొత్త కీకి స్వయంచాలకంగా 0 కేటాయిస్తుంది. కౌంటర్లు తయారు చేయడానికి ఉపయోగపడుతుంది.
• defaultdict(set): డూప్లికేట్స్ లేని ప్రత్యేక విలువలను సమూహపరచడానికి set() ను ఇస్తుంది.

5 మల్టీ-లెవల్ డేటా గ్రూపింగ్ విత్ defaultdict(list)

సాధారణ డిక్షనరీలో ఐదు లైన్ల కోడ్ పట్టే గ్రూపింగ్ పనిని defaultdict కేవలం ఒకే ఒక్క లైన్‌లో ఎలా సులభతరం చేస్తుందో చూడండి:

6 collections.deque — డబుల్ ఎండెడ్ క్యూ (O(1) vs O(N))

deque (ఉచ్ఛారణ: "డెక్" - Double-Ended Queue) అనేది CPython లో డబ్లీ లింక్డ్ లిస్ట్ (Doubly Linked List of Blocks) రూపంలో నిర్మించబడిన హై-స్పీడ్ డేటా స్ట్రక్చర్.

లిస్ట్ వర్సెస్ డెక్ పెర్ఫార్మెన్స్ పోలిక:

సర్క్యులర్ బఫర్ (Circular Buffer with maxlen): డెక్‌ను సృష్టించేటప్పుడు d = deque(maxlen=5) అని గరిష్ట పరిమాణాన్ని నిర్దేశించవచ్చు. బఫర్ నిండిపోయిన తర్వాత కొత్త ఎలిమెంట్ రాగానే, అత్యంత పాత ఎలిమెంట్ స్వయంచాలకంగా బయటకు వెళ్లిపోతుంది! ఇది లైవ్ లాగింగ్ మరియు స్ట్రీమింగ్ మూవీంగ్ యావరేజ్‌లకు వరప్రసాదం.

7 కోడ్ డెమో 2: స్లైడింగ్ విండో మూవింగ్ యావరేజ్ with deque(maxlen=K)

సెన్సార్ డేటా లేదా స్టాక్ ప్రైస్ టిక్కర్ల నుండి స్థిరమైన గత 4 టిక్స్ యొక్క మూవింగ్ యావరేజ్‌ను deque(maxlen=K) ద్వారా ఎలా లెక్కిస్తామో చూడండి:

# collections.deque సర్క్యులర్ బఫర్ డెమో
from collections import deque

# కేవలం గత 4 రీడింగులను మాత్రమే భద్రపరిచే స్లైడింగ్ విండో బఫర్
recent_prices = deque(maxlen=4)

incoming_stream = [100.5, 102.0, 101.5, 103.0, 104.5, 103.5, 106.0]

print("=== స్లైడింగ్ విండో మూవింగ్ యావరేజ్ (Window Size = 4) ===")
for tick in incoming_stream:
    recent_prices.append(tick)
    current_avg = sum(recent_prices) / len(recent_prices)
    print(f"కొత్త ధర : ₹{tick:<6.2f} -> ప్రస్తుత బఫర్ : {list(recent_prices)} -> సగటు : ₹{current_avg:.2f}")

8 collections.OrderedDict & LRU Cache బేసిక్స్

పైథాన్ 3.7 నుండి సాధారణ డిక్షనరీలు కూడా ఇన్సర్ట్ చేసిన వరుస క్రమాన్ని గుర్తుపెట్టుకుంటున్నాయి. అయినప్పటికీ OrderedDict లో సాధారణ డిక్షనరీలో లేని రెండు శక్తివంతమైన మెథడ్స్ ఉన్నాయి:

• od.move_to_end(key, last=True): పేర్కొన్న కీని డిక్షనరీ చివరకు (లేదా last=False అయితే ప్రారంభానికి) అత్యంత వేగంగా తరలిస్తుంది. ఇది LRU (Least Recently Used) Cache లను సొంతంగా నిర్మించడానికి ప్రధాన పునాది!
• క్రమాన్ని పరిగణించే సమానత్వ పోలిక (Equality by Order): రెండు సాధారణ డిక్షనరీలలో ఎలిమెంట్లు వేర్వేరు వరుసలో ఉన్నా అవి సమానమే ({'a':1, 'b':2} == {'b':2, 'a':1} → True). కానీ OrderedDict లో క్రమం కూడా ఖచ్చితంగా సరిపోలితేనే True అవుతుంది!

9 collections.ChainMap — కాన్ఫిగరేషన్ లేయరింగ్

ChainMap అనేది బహుళ డిక్షనరీలను ఒకే సింగిల్ లాజికల్ వ్యూగా గ్రూప్ చేస్తుంది. మెమరీలో డేటాను నకలు చేయకుండా (కాపీ చేయకుండా) చెయిన్ చేస్తుంది.

అప్లికేషన్ కాన్ఫిగరేషన్ ప్రాధాన్యతలలో ఇది విస్తృతంగా వాడబడుతుంది: కమాండ్ లైన్ ఆర్గ్యుమెంట్స్ > ఎన్విరాన్‌మెంట్ వేరియబుల్స్ > డిఫాల్ట్ కాన్ఫిగ్ ఫైల్.

10 heapq మాడ్యూల్ — బైనరీ హీప్ & ప్రయారిటీ క్యూస్

heapq మాడ్యూల్ పైథాన్‌లో మిన్-హీప్ (Min-Heap) అల్గారిథమ్‌ను సాధారణ లిస్ట్‌లపై అమలు చేస్తుంది. ఇందులో మొదటి ఎలిమెంట్ heap[0] ఎల్లప్పుడూ ఆ కలెక్షన్‌లోని అత్యల్ప (Smallest) అంశంగా ఉంటుంది.

ప్రధాన ఆపరేషన్లు & టైమ్ కాంప్లెక్సిటీ:

• heapq.heapify(list): సాధారణ లిస్ట్‌ను ఇన్-ప్లేస్‌గా O(N) లీనియర్ టైమ్‌లో హీప్‌గా మారుస్తుంది.
• heapq.heappush(heap, item): నూతన అంశాన్ని జోడించి హీప్ నియమాన్ని O(log N) సమయంలో కాపాడుతుంది.
• heapq.heappop(heap): అత్యల్ప అంశాన్ని O(log N) సమయంలో బయటకు తీసి తిరిగి హీప్‌ను సర్దుబాటు చేస్తుంది.
• heapq.nlargest(k, iterable) మరియు heapq.nsmallest(k, iterable): మొత్తం డేటాను సార్ట్ చేయకుండానే టాప్ K అంశాలను అత్యంత సమర్థవంతంగా అందిస్తాయి.
• మ్యాక్స్-హీప్ ట్రిక్ (Max-Heap Trick): పైథాన్‌లో నేరుగా Max-Heap లేదు. కానీ సంఖ్యలను నెగటివ్‌గా (-priority) మార్చి హీప్‌లో పుష్ చేయడం ద్వారా అత్యున్నత ప్రాధాన్యత అంశాన్ని మొదట వచ్చేలా సులభంగా చేయవచ్చు!

11 కోడ్ డెమో 3: హాస్పిటల్ ఎమర్జెన్సీ ట్రయేజ్ & టాస్క్ షెడ్యూలర్

రోగుల ఆరోగ్య తీవ్రత ఆధారంగా (Priority 1 = అత్యవసరం) తదుపరి చికిత్స పొందాల్సిన రోగిని heapq ప్రయారిటీ క్యూ ద్వారా ఎలా ప్రాసెస్ చేస్తారో చూద్దాం:

# heapq ప్రయారిటీ క్యూ డెమో
import heapq

# ఆసుపత్రి ఎమర్జెన్సీ వార్డ్ క్యూ (Min-Heap)
# Tuple structure: (Priority, Patient Name, Condition)
# Priority: 1 = క్రిటికల్, 2 = తీవ్రమైన, 3 = సాధారణ
triage_queue = []

# కొత్త రోగులను చేర్చడం (heappush)
heapq.heappush(triage_queue, (3, "రాము", "సాధారణ జ్వరం"))
heapq.heappush(triage_queue, (1, "రమేష్", "గుండెపోటు లక్షణాలు"))
heapq.heappush(triage_queue, (2, "కవిత", "ఎముక విరిగింది"))
heapq.heappush(triage_queue, (1, "సునీత", "తీవ్రమైన శ్వాసకోశ సమస్య"))

print("=== 🏥 ICU ఎమర్జెన్సీ ట్రయేజ్ ట్రీట్‌మెంట్ ఆర్డర్ ===")
while triage_queue:
    priority, name, condition = heapq.heappop(triage_queue)
    badge = "🚨 అత్యవసరం (ICU)" if priority == 1 else ("⚠️ తీవ్రమైనది" if priority == 2 else "🟢 సాధారణం")
    print(f"ప్రాధాన్యత {priority} [{badge}]: రోగి: {name:<10} సమస్య: {condition}")

12 కామన్ బిగినర్స్ మిస్టేక్స్ & ప్రొడక్షన్ బెస్ట్ ప్రాక్టీసెస్

• Mistake 1: Deque లో మధ్యలోని ఎలిమెంట్లను ఇండెక్స్ ద్వారా వెతకడం: deque లో d[500] అని రాస్తే అది లింక్డ్ బ్లాక్స్ ద్వారా లీనియర్‌గా O(N) సమయం తీసుకుంటుంది. రాండమ్ రీడింగ్ ఎక్కువగా ఉంటే సాధారణ లిస్ట్‌ను వాడండి.
• Mistake 2: Counter లో కీ లేదు అని అనుమానించడం: Counter లో కీ లేకపోయినా 0 వస్తుంది. కాబట్టి కీ ఉందో లేదో తెలుసుకోవడానికి if 'x' in c: వాడాలి తప్ప if c['x'] > 0: అని పొరబడకూడదు (ఎందుకంటే 0 ఉన్న కీ కూడా ఉండవచ్చు).
• Mistake 3: heapq.heapify లేకుండా సాధారణ లిస్ట్‌పై heappop వాడటం: సాధారణ లిస్ట్‌ను ముందుగా heapify() చేయకుండా heappop() చేస్తే అది హీప్ క్రమాన్ని పాటించదు మరియు తప్పుడు ఫలితాలను ఇస్తుంది.
• Best Practice: FIFO Queue లకు collections.deque: ఫస్ట్-ఇన్-ఫస్ట్-అవుట్ క్యూలకు ఎప్పుడూ list.pop(0) వాడకండి. ఎల్లప్పుడూ deque.popleft() ను ఎంచుకోండి.

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "High-Frequency Trading & Order Execution Engine"

ఈ పదిహేనవ అధ్యాయంలో నేర్చుకున్న అన్ని అడ్వాన్స్‌డ్ స్ట్రక్చర్లను (Counter ఫ్రీక్వెన్సీ, defaultdict గ్రూపింగ్, deque స్లైడింగ్ బఫర్, heapq ప్రయారిటీ ఆర్డర్ బుక్) మిళితం చేస్తూ — సెకనుకు వేల ఆర్డర్లను ప్రాసెస్ చేసే పూర్తి స్థాయి Real-time High-Frequency Trading & Order Execution Engine ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 15 మినీ ప్రాజెక్ట్: High-Frequency Trading & Order Execution Engine
# కాన్సెప్ట్స్: collections.defaultdict, deque (Sliding Window Tick Buffer),
#             collections.Counter (Volume Analytics), heapq (Priority Order Book)
# =====================================================================
from collections import defaultdict, deque, Counter
import heapq
import time

class TradingEngine:
    def __init__(self):
        # 1. ప్రయారిటీ బై ఆర్డర్ బుక్ (Min-Heap with Negated Price for Max-Price Buy Priority)
        # Structure: (-buy_price, order_id, shares, trader)
        self.buy_order_book = []

        # 2. గత 5 మార్కెట్ టిక్స్ స్లైడింగ్ బఫర్ (deque circular buffer)
        self.market_price_stream = deque(maxlen=5)

        # 3. ట్రేడర్ల వారీగా పోర్ట్‌ఫోలియో షేర్ల బ్యాలెన్స్ (defaultdict(int))
        self.trader_portfolios = defaultdict(int)

        # 4. స్టాక్ సింబల్స్ ట్రేడింగ్ వాల్యూమ్ విశ్లేషణ (Counter)
        self.volume_counter = Counter()

    def add_market_tick(self, stock_symbol: str, price: float):
        """లైవ్ మార్కెట్ ప్రైస్ టిక్‌ను స్లైడింగ్ విండోలోకి స్వీకరిస్తుంది."""
        self.market_price_stream.append(price)
        current_moving_avg = sum(self.market_price_stream) / len(self.market_price_stream)
        print(f"📈 [TICK] {stock_symbol:<6} ధర: ₹{price:<7.2f} (గత 5 టిక్స్ సగటు: ₹{current_moving_avg:.2f})")

    def place_buy_order(self, order_id: str, stock: str, price: float, shares: int, trader: str):
        """కొనుగోలు ఆర్డర్‌ను హీప్ ప్రయారిటీ క్యూలో నమోదు చేస్తుంది."""
        # అత్యధిక ధరకు కొనేవారికి మొదటి ప్రాధాన్యత ఇవ్వడానికి నెగటివ్ ప్రైస్ వాడతాం!
        heapq.heappush(self.buy_order_book, (-price, order_id, stock, shares, trader))
        print(f"📥 [ORDER] {trader} -> Buy {shares} {stock} @ ₹{price}")

    def execute_top_orders(self):
        """ఆర్డర్ బుక్ నుండి అత్యున్నత బిడ్ ప్రైస్ ఉన్న ఆర్డర్లను O(log N) వేగంతో ఎగ్జిక్యూట్ చేస్తుంది."""
        print("\n" + "=" * 74)
        print(f"{'⚡ మన ట్రేడింగ్ ఎక్స్ఛేంజ్ — ఆర్డర్ ఎగ్జిక్యూషన్ రిపోర్ట్ 2026':^74}")
        print("=" * 74)
        print(f"{'ఆర్డర్ ID':<10} {'స్టాక్':<8} {'ఎగ్జిక్యూట్ ధర':>14} {'షేర్లు':>8} {'ట్రేడర్':<14} {'విలువ (₹)':>14}")
        print("-" * 74)

        while self.buy_order_book:
            neg_price, order_id, stock, shares, trader = heapq.heappop(self.buy_order_book)
            exec_price = -neg_price
            trade_value = exec_price * shares

            # పోర్ట్‌ఫోలియో & వాల్యూమ్ అప్‌డేట్
            self.trader_portfolios[trader] += shares
            self.volume_counter[stock] += shares

            print(f"{order_id:<10} {stock:<8} ₹{exec_price:>12.2f} {shares:>8} {trader:<14} ₹{trade_value:>12,.2f}")

        print("=" * 74)

    def print_analytics_summary(self):
        """Counter & defaultdict ద్వారా పోర్ట్‌ఫోలియో & వాల్యూమ్ సమ్మరీని ఇస్తుంది."""
        print("\n📊 అత్యధిక వాల్యూమ్ ట్రేడ్ అయిన స్టాక్స్ (Top Traded Symbols):")
        for stock, total_shares in self.volume_counter.most_common():
            print(f"  • {stock:<8} : మొత్తం {total_shares:,} షేర్లు ట్రేడ్ అయ్యాయి")

        print("\n💼 ట్రేడర్ల తాజా షేర్ల పోర్ట్‌ఫోలియో (defaultdict balance):")
        for trader, total_shares in self.trader_portfolios.items():
            print(f"  • {trader:<14} : {total_shares} షేర్లు కలిగి ఉన్నారు")
        print("=" * 74 + "\n")

# ఇంజిన్ టెస్టింగ్
engine = TradingEngine()

print("--- 1. లైవ్ మార్కెట్ ప్రైస్ టిక్స్ స్ట్రీమింగ్ (deque) ---")
engine.add_market_tick("TCS", 3850.0)
engine.add_market_tick("TCS", 3865.0)
engine.add_market_tick("TCS", 3840.0)
engine.add_market_tick("TCS", 3875.0)
engine.add_market_tick("TCS", 3890.0)
engine.add_market_tick("TCS", 3910.0)

print("\n--- 2. ఆర్డర్స్ నమోదు (heapq priority) ---")
engine.place_buy_order("ORD-101", "TCS", 3870.0, 50, "రాహుల్")
engine.place_buy_order("ORD-102", "INFY", 1520.0, 100, "అంజలి")
engine.place_buy_order("ORD-103", "TCS", 3905.0, 30, "సురేష్") # అత్యధిక బిడ్!
engine.place_buy_order("ORD-104", "INFY", 1550.0, 200, "రాహుల్")

engine.execute_top_orders()
engine.print_analytics_summary()

★ ఈ అధ్యాయంపై ప్రాక్టీస్ క్విజ్ (Knowledge Check)