వేరియబుల్ ఆర్గ్యుమెంట్స్ & స్కోప్ (*args, **kwargs & LEGB)

1 వేరియబుల్ ఆర్గ్యుమెంట్స్ ఎందుకు అవసరం? (Flexible Signatures)

సాధారణ ఫంక్షన్లలో మనం ఎన్ని పారామీటర్లను రాస్తే, కాల్ చేసేటప్పుడు సరిగ్గా అన్ని ఆర్గ్యుమెంట్లనే పంపాలి. ఒక్కటి ఎక్కువైనా లేదా తక్కువైనా పైథాన్ వెంటనే TypeError విసురుతుంది:

కానీ వాస్తవ ప్రపంచంలో ఫంక్షన్లు అత్యంత సౌకర్యవంతంగా (Flexible) ఉండాలి. ఉదాహరణకు పైథాన్ యొక్క బిల్ట్-ఇన్ print() ఫంక్షన్‌ను గమనించండి — దానికి మీరు ఒక పదం పంపినా ప్రింట్ చేస్తుంది, కామాలతో వేరుచేసి వంద పదాలు పంపినా వాటన్నింటినీ ప్రింట్ చేస్తుంది! ఈ విధమైన ఫ్లెక్సిబిలిటీని మన స్వంత ఫంక్షన్లకు అందించడానికి *args మరియు **kwargs ఉపయోగపడతాయి.

2 *args — ఆర్బిట్రరీ పొజిషనల్ ఆర్గ్యుమెంట్స్ (Tuple Packing)

ఫంక్షన్ పారామీటర్ ముందు ఒక స్టార్ సింబల్ * పెడితే, అది కాల్ చేసేటప్పుడు పంపిన అదనపు పొజిషనల్ ఆర్గ్యుమెంట్లు అన్నింటినీ ఒకే ఒక టుపుల్ (Tuple) లోకి ప్యాక్ చేస్తుంది.

• పేరు నియమం: సాంప్రదాయకంగా ప్రోగ్రామర్లు *args (arguments) అని పిలుస్తారు, కానీ సాంకేతికంగా స్టార్ తర్వాత ఏ పేరైనా పెట్టవచ్చు (ఉదా: *numbers, *items). అసలైన మ్యాజిక్ స్టార్ * గుర్తులోనే ఉంది!
• టుపుల్ రూపంలోకి ప్యాకింగ్: ఫంక్షన్ లోపల args అనేది ఒక ఇమ్మ్యుటబుల్ టుపుల్ అవుతుంది. దానిపై మనం లూప్ చేయవచ్చు, len(), sum() వంటి ఆపరేషన్లు నిశ్చింతగా చేయవచ్చు.

3 **kwargs — ఆర్బిట్రరీ కీవర్డ్ ఆర్గ్యుమెంట్స్ (Dict Packing)

ఫంక్షన్ పారామీటర్ ముందు డబుల్ స్టార్ సింబల్ ** పెడితే, అది కాల్ చేసేటప్పుడు పంపిన అదనపు కీవర్డ్ ఆర్గ్యుమెంట్లు (Named Arguments: key=value) అన్నింటినీ ఒక డిక్షనరీ (Dictionary) లోకి ప్యాక్ చేస్తుంది.

• పేరు నియమం: దీనిని సాంప్రదాయకంగా **kwargs (keyword arguments) అంటారు.
• డిక్షనరీ రూపంలోకి ప్యాకింగ్: ఫంక్షన్ లోపల kwargs అనేది ఒక సాధారణ డిక్షనరీ అవుతుంది. kwargs.items(), kwargs.get() మెథడ్స్ ద్వారా డైనమిక్ ఫీల్డ్స్‌ను యాక్సెస్ చేయవచ్చు.

4 ఫంక్షన్ పారామీటర్ల మాస్టర్ ఆర్డరింగ్ రూల్ (The Master Ordering Rule)

ఒకే ఫంక్షన్‌లో సాధారణ పారామీటర్లు, డిఫాల్ట్ పారామీటర్లు, *args, కీవర్డ్-ఓన్లీ, మరియు **kwargs లను కలిపి రాయాల్సి వచ్చినప్పుడు, పైథాన్ ఒక ఖచ్చితమైన వరుస క్రమాన్ని నిర్దేశిస్తుంది:

5 ఆర్గ్యుమెంట్ అన్‌ప్యాకింగ్ ట్రిక్స్ (Unpacking with * & **)

స్టార్ ఆపరేటర్ కేవలం పారామీటర్లను ప్యాక్ చేయడానికే కాకుండా, ఇప్పటికే ఉన్న లిస్ట్‌లు, టుపుల్స్ మరియు డిక్షనరీలను ఫంక్షన్ కాల్స్‌లోకి అన్‌ప్యాక్ (విడదీయడానికి) కూడా ఉపయోగపడుతుంది:

• లిస్ట్/టుపుల్ అన్‌ప్యాకింగ్ (*): nums = [10, 20, 30] ఉంటే add(*nums) అని పంపితే అది add(10, 20, 30) గా మారుతుంది.
• డిక్షనరీ అన్‌ప్యాకింగ్ (**): user_data = {"name": "రమ్య", "age": 24} ఉంటే create_profile(**user_data) అని పంపితే అది create_profile(name="రమ్య", age=24) గా విడిపోతుంది.

6 కోడ్ డెమో 1: డైనమిక్ API రిక్వెస్ట్ బిల్డర్ with *args & **kwargs

ఎన్ని పాత్ పారామీటర్లు మరియు క్వెరీ పారామీటర్లు వచ్చినా డైనమిక్‌గా సరైన API URL ను నిర్మించే ఫంక్షన్‌ను పరిశీలిద్దాం:

# =====================================================================
# చాప్టర్ 17 డెమో 1: *args & **kwargs డైనమిక్ API URL బిల్డర్
# =====================================================================

def build_api_endpoint(base_domain: str, *path_segments, protocol: str = "https", **query_params) -> str:
    """డైనమిక్ పాత్‌లు మరియు క్వెరీ పారామీటర్లతో API ఎండ్‌పాయింట్‌ను నిర్మిస్తుంది."""
    # 1. *args లోని అన్ని సెగ్మెంట్లను / తో జాయిన్ చేయడం
    clean_paths = [str(seg).strip("/") for seg in path_segments if seg]
    path_url = "/".join(clean_paths)

    # 2. **kwargs లోని క్వెరీ పారామీటర్లను key=value గా మార్చడం
    query_parts = [f"{k}={v}" for k, v in query_params.items()]
    query_string = ("?" + "&".join(query_parts)) if query_parts else ""

    full_url = f"{protocol}://{base_domain}/{path_url}{query_string}"
    return full_url

# టెస్ట్ 1: సాధారణ యూజర్ పాత్ & ఫిల్టర్లు
url_1 = build_api_endpoint(
    "api.ourcompiler.com",
    "v1", "users", 1042, "orders",
    protocol="https",
    status="delivered",
    page=1,
    limit=20
)
print("ఎండ్‌పాయింట్ 1 :", url_1)

# టెస్ట్ 2: ఆర్గ్యుమెంట్ అన్‌ప్యాకింగ్ (*paths, **filters)
extra_paths = ["v2", "products", "laptops"]
extra_filters = {"brand": "asus", "min_ram_gb": 16}

url_2 = build_api_endpoint("api.ourcompiler.com", *extra_paths, **extra_filters)
print("ఎండ్‌పాయింట్ 2 :", url_2)

7 వేరియబుల్ స్కోప్ అంటే ఏమిటి? (Variable Scope & Lifetime)

పైథాన్‌లో ఒక వేరియబుల్‌ను డిక్లేర్ చేసినప్పుడు, అది ప్రోగ్రామ్‌లోని ఏ ఏ ప్రదేశాలలో అందుబాటులో ఉంటుంది (Visibility) మరియు మెమరీలో ఎంతకాలం జీవించి ఉంటుంది (Lifetime) అనే దానిని నిర్ణయించే నియమ నిబంధనలనే స్కోప్ (Scope) అంటారు.

• లోకల్ స్కోప్ (Local): ఫంక్షన్ లోపల సృష్టించిన వేరియబుల్స్ ఫంక్షన్ రన్ అవుతున్నప్పుడు మాత్రమే బ్రతికి ఉంటాయి. ఫంక్షన్ ముగియగానే అవి తుడిచిపెట్టుకుపోతాయి. బయట నుండి వాటిని చదవలేము (NameError).
• గ్లోబల్ స్కోప్ (Global): ఫంక్షన్ల వెలుపల, ప్రధాన స్క్రిప్ట్‌లో రాసే వేరియబుల్స్ ప్రోగ్రామ్ మొత్తం ఎక్కడి నుంచైనా చదవడానికి అందుబాటులో ఉంటాయి.

8 The LEGB స్కోప్ రూల్ డీప్ డైవ్ (Local, Enclosing, Global, Built-in)

పైథాన్‌లో మీరు ఏదైనా ఒక వేరియబుల్ పేరును ఉపయోగించినప్పుడు, ఇంటర్ప్రెటర్ ఆ పేరును ఎలా వెతుకుతుంది? దీనికి పైథాన్ ఒక ఖచ్చితమైన 4-దశల క్రమాన్ని పాటిస్తుంది — దీనినే LEGB Rule అంటారు:

బైట్‌కోడ్ స్థాయిలో LEGB అంతర్గత విశ్లేషణ:

• 1. Local (L) — LOAD_FAST ఆప్టిమైజేషన్: లోకల్ వేరియబుల్స్ శోధన డిక్షనరీలో కాకుండా, CPython స్టాక్ ఫ్రేమ్‌లోని స్థిరమైన C-అరే ద్వారా నేరుగా ఇండెక్స్ చేయబడుతుంది. అందుకే లోకల్ వేరియబుల్స్ యాక్సెస్ అత్యంత మెరుపు వేగంతో జరుగుతుంది.
• 2. Enclosing (E) — LOAD_DEREF & Cell Objects: లోపలి ఫంక్షన్ బయటి ఫంక్షన్ వేరియబుల్స్‌ను వాడుతున్నప్పుడు, CPython హీప్ మెమరీలో ఒక ప్రత్యేకమైన Cell Object ను కేటాయిస్తుంది. బయటి ఫంక్షన్ ఎగ్జిక్యూషన్ ముగిసిన తర్వాత కూడా ఈ డేటా సజీవంగా ఉంటుంది (క్లోజర్ ఆర్కిటెక్చర్).
• 3. Global (G) — LOAD_GLOBAL: ప్రస్తుత మాడ్యూల్ యొక్క గ్లోబల్ డిక్షనరీ globals() లో కీ-వాల్యూ శోధన జరుగుతుంది.
• 4. Built-in (B): పైథాన్ ప్రారంభమైనప్పుడే లోడ్ అయ్యే builtins.__dict__ లో వెతుకుతుంది. ఇక్కడే బిగినర్స్ ఒక పెద్ద తప్పు చేస్తుంటారు: list = [1, 2, 3] అని రాస్తే, మీరు బిల్ట్-ఇన్ list ఫంక్షన్‌ను గ్లోబల్ స్కోప్‌లో షాడో (మరుగునపరచడం) చేస్తారు! ఆ తర్వాత list() కన్‌స్ట్రక్టర్ పనిచేయదు.

9 global కీవర్డ్ — గ్లోబల్ స్టేట్ మోడిఫికేషన్స్ & ప్రమాదాలు

ఒక ఫంక్షన్ లోపల ఉంటూ గ్లోబల్ వేరియబుల్‌లోని విలువను చదవడం సులభమే. కానీ దానిని సవరించాలని (Modify) చూసినప్పుడు, పైథాన్ ఆ పేరుతో ఒక సరికొత్త లోకల్ వేరియబుల్‌ను సృష్టిస్తుంది తప్ప గ్లోబల్ వేరియబుల్‌ను మార్చదు!

ఫంక్షన్ లోపల నుండే అసలైన గ్లోబల్ వేరియబుల్‌ను మార్చాలంటే global కీవర్డ్‌ను ఉపయోగించాలి:

10 nonlocal కీవర్డ్ — నెస్టెడ్ ఫంక్షన్స్ & Closures ఆర్కిటెక్చర్

ఒక ఫంక్షన్ లోపల మరొక ఫంక్షన్‌ను రాసినప్పుడు (Nested Functions), లోపలి ఫంక్షన్ తన బయట ఉన్న ఫంక్షన్‌లోని వేరియబుల్‌ను సవరించడానికి nonlocal కీవర్డ్‌ను ఉపయోగిస్తుంది.

క్లోజర్ (Closure) అంటే ఏమిటి?
ఒక ఇన్నర్ ఫంక్షన్ తన బయటి ఫంక్షన్ ఎగ్జిక్యూషన్ ముగిసిపోయినప్పటికీ, బయటి ఫంక్షన్ లోని వేరియబుల్స్ (Enclosing Scope State) ను గుర్తుపెట్టుకుని ఉండగలిగితే దానిని క్లోజర్ (Closure) అంటారు.

• ఇది గ్లోబల్ వేరియబుల్‌ను మార్చదు; కేవలం చుట్టూ ఉన్న క్లోజర్ వేరియబుల్‌ను మాత్రమే సవరిస్తుంది.
• పైథాన్‌లో డెకరేటర్స్ (Decorators) మరియు ఫ్యాక్టరీ ఫంక్షన్ల నిర్మాణానికి క్లోజర్స్ అత్యంత ప్రాథమిక పునాది.
• ప్రతి క్లోజర్ ఫంక్షన్‌కు __closure__ అనే స్పెషల్ అట్రిబ్యూట్ ఉంటుంది, ఇందులో ఆ సెల్ వాల్యూస్ (cell_contents) భద్రంగా ఉంటాయి.

11 కోడ్ డెమో 2: క్లోజర్-బేస్డ్ బ్యాంక్ వాలెట్ with nonlocal

nonlocal కీవర్డ్ ద్వారా ఒక ప్రైవేట్ బ్యాలెన్స్‌ను భద్రపరిచే క్లోజర్ ఇంప్లిమెంటేషన్‌ను క్రింద పరిశీలిద్దాం:

# nonlocal & క్లోజర్ డెమో
def make_secure_wallet(initial_balance: float):
    """ఒక ప్రైవేట్ బ్యాలెన్స్ స్టేట్ కలిగిన వాలెట్ ఫంక్షన్‌ను సృష్టిస్తుంది."""
    balance = initial_balance  # Enclosing Scope Variable

    def spend(amount: float):
        nonlocal balance  # బయటి ఫంక్షన్ లోని balance ను మార్చడానికి అనుమతి!
        if amount > balance:
            return f"❌ లావాదేవీ విఫలం! నిల్వ సరిపోదు (ప్రస్తుతం: ₹{balance:,.2f})"
        balance -= amount
        return f"✅ ₹{amount:,.2f} చెల్లించబడింది. మిగిలిన బ్యాలెన్స్: ₹{balance:,.2f}"

    return spend

# వాలెట్ సృష్టి (రాహుల్ వాలెట్ ప్రారంభ బ్యాలెన్స్ ₹5,000)
rahul_wallet = make_secure_wallet(5000.0)

print(rahul_wallet(1200)) # 5000 - 1200 = 3800
print(rahul_wallet(2500)) # 3800 - 2500 = 1300
print(rahul_wallet(2000)) # ఫెయిల్! (1300 మాత్రమే ఉంది)

12 కామన్ బిగినర్స్ మిస్టేక్స్ & UnboundLocalError బగ్

• The Infamous UnboundLocalError:
  count = 10
  def increment():
      print(count) # UnboundLocalError: cannot access local variable 'count' where it is not associated with a value!
      count = 20
  కారణం & పరిష్కారం: ఫంక్షన్ లోపల ఎక్కడైనా count = 20 అని అసైన్‌మెంట్ కనిపిస్తే, పైథాన్ ఆ ఫంక్షన్ మొత్తానికి count ను లోకల్ వేరియబుల్‌గా గుర్తిస్తుంది. ఫలితంగా అసైన్ చేయడానికి ముందే దాన్ని ప్రింట్ చేయడానికి చూసినప్పుడు ఈ ఎర్రర్ వస్తుంది. గ్లోబల్ వేరియబుల్ అయితే ఫంక్షన్ పైన global count అని ప్రకటించాలి.
• Mistake 2: *args తర్వాత పొజిషనల్ ఆర్గ్యుమెంట్స్ రాయడం: def f(*args, x): అని రాస్తే, x తప్పనిసరిగా Keyword-Only అవుతుంది. కాల్ చేసేటప్పుడు f(1, 2, x=3) అని పేరుతో పిలవాలి తప్ప పొజిషనల్‌గా పాస్ చేయలేము.
• Mistake 3: **kwargs తర్వాత ఏదైనా పారామీటర్ పెట్టడం: **kwargs ఎల్లప్పుడూ ఫంక్షన్ సిగ్నేచర్‌లో చిట్టచివరి పారామీటర్‌గా మాత్రమే ఉండాలి! దాని తర్వాత ఇంకేదీ ఉండకూడదు.
• Mistake 4: గ్లోబల్ మ్యూటబుల్ ఆబ్జెక్టులను సవరించడంలో గందరగోళం: గ్లోబల్ లిస్ట్‌లోకి gl_list.append(5) అని రాస్తే global కీవర్డ్ అవసరం లేదు (ఎందుకంటే రీ-అసైన్‌మెంట్ జరగలేదు, ఇన్-ప్లేస్ మ్యుటేషన్ మాత్రమే). కానీ gl_list = [5] అని కొత్త లిస్ట్‌ను కేటాయించాలంటే తప్పనిసరిగా global gl_list ఉండాలి!
• Best Practice: ఫంక్షన్ డెకరేటర్లలో యూనివర్సల్ పాసింగ్: పైథాన్‌లో డెకరేటర్లు రాసేటప్పుడు wrapper(*args, **kwargs) అని రాస్తే అది అసలైన ఫంక్షన్‌కు ఏ రకమైన ఆర్గ్యుమెంట్లు వచ్చినా ఎటువంటి నష్టం లేకుండా నిశ్చింతగా పాస్ చేస్తుంది.

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Enterprise Microservice Event Logger & Auditing Dispatcher"

ఈ పదిహేడవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (*args, **kwargs, అన్‌ప్యాకింగ్, LEGB స్కోప్, క్లోజర్స్, గ్లోబల్ ఆడిట్ కౌంటర్స్) సమగ్రంగా అనుసంధానిస్తూ — వేలాది మైక్రోసర్వీసుల నుండి వచ్చే విభిన్న పేలోడ్లను ప్రాసెస్ చేసే పూర్తి స్థాయి Enterprise Event Logger & Auditing Dispatcher Engine ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 17 మినీ ప్రాజెక్ట్: Microservice Event Logger & Audit Dispatcher
# కాన్సెప్ట్స్: *args (Dynamic Tags), **kwargs (Flexible Event Payload),
#             LEGB Scope Resolution, Closure Metrics Tracker, Unpacking
# =====================================================================
from datetime import datetime

# Global Audit Registry (LEGB - Global Scope)
TOTAL_EVENTS_DISPATCHED = 0
SEVERITY_COUNTS = {"INFO": 0, "WARNING": 0, "CRITICAL": 0}

def create_service_event_dispatcher(service_name: str, environment: str = "PRODUCTION"):
    """ఒక నిర్దిష్ట మైక్రోసర్వీస్ కోసం క్లోజర్-ఆధారిత ఈవెంట్ డిస్పాచర్‌ను సృష్టిస్తుంది."""
    local_event_counter = 0  # Enclosing Scope Variable

    def log_event(severity: str, event_action: str, *tags, **metadata):
        nonlocal local_event_counter
        global TOTAL_EVENTS_DISPATCHED, SEVERITY_COUNTS

        local_event_counter += 1
        TOTAL_EVENTS_DISPATCHED += 1
        SEVERITY_COUNTS[severity] = SEVERITY_COUNTS.get(severity, 0) + 1

        timestamp = datetime.now().strftime("%H:%M:%S")
        tag_str = " ".join([f"#{t}" for t in tags]) if tags else "#UNTYPED"

        # కన్సోల్ ఆడిట్ అవుట్‌పుట్
        icon = "🔴" if severity == "CRITICAL" else ("🟡" if severity == "WARNING" else "🟢")
        print(f"[{timestamp}] {icon} [{severity:<8}] [{service_name}] #{local_event_counter}")
        print(f"  యాక్షన్: {event_action:<28} ట్యాగ్స్: {tag_str}")

        if metadata:
            print("  మెటాడేటా పేలోడ్:")
            for k, v in metadata.items():
                print(f"    • {k:<15} : {v}")
        print("-" * 65)

    return log_event

# 1. రెండు వేర్వేరు మైక్రోసర్వీసుల కోసం డిస్పాచర్లను సృష్టించడం
auth_service_logger = create_service_event_dispatcher("AUTH-SERVICE")
payment_service_logger = create_service_event_dispatcher("PAYMENT-SERVICE")

print("\n" + "=" * 65)
print(f"{'🌐 మన ఎంటర్‌ప్రైజ్ మైక్రోసర్వీస్ ఈవెంట్ ఆడిట్ స్ట్రీమ్ 2026':^65}")
print("=" * 65)

# 2. AUTH SERVICE లాగ్స్ (*args ద్వారా ట్యాగ్స్, **kwargs ద్వారా మెటాడేటా)
auth_service_logger(
    "INFO", "USER_LOGIN_SUCCESS",
    "security", "oauth2",
    user_id="USR-9921", ip="192.168.1.100", browser="Chrome 122"
)

auth_service_logger(
    "WARNING", "FAILED_PASSWORD_ATTEMPT",
    "bruteforce_risk", "security",
    user_id="USR-8810", ip="45.154.255.88", attempts_count=3
)

# 3. PAYMENT SERVICE లాగ్స్ (డైనమిక్ పేమెంట్ ఫీల్డ్స్)
payment_payload = {
    "txn_id": "TXN-9008129",
    "amount_inr": 24999.0,
    "gateway": "RAZORPAY",
    "card_network": "VISA"
}
payment_service_logger("INFO", "PAYMENT_CAPTURED", "finance", "instant", **payment_payload)

# 4. CRITICAL EVENT
payment_service_logger(
    "CRITICAL", "GATEWAY_TIMEOUT",
    "critical", "outage",
    gateway="RAZORPAY", error_code="ERR_504_TIMEOUT", retry_attempt=3
)

# 5. గ్లోబల్ మెట్రిక్స్ సమ్మరీ (Global Scope Audit)
print("=" * 65)
print(f"మొత్తం డిస్పాచ్ అయిన ఈవెంట్లు : {TOTAL_EVENTS_DISPATCHED}")
print(f"సెక్యూరిటీ తీవ్రత సమ్మరీ     : {SEVERITY_COUNTS}")
print("=" * 65 + "\n")

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