35:"/_next/static/chunks/0_6qdgbl18thf.js" 36:"/_next/static/chunks/3316o_1ddm9ab.js" 37:I[96601,["$1","$22","$23","$35","$36"],"default"] 38:I[58709,["$1","$22","$23","$35","$36"],"default"] 39:I[80423,["$1","$22","$23","$35","$36"],"default"] 3a:T8f3,class BankAccount: """Secure bank account - balance is private""" def __init__(self, account_number, initial_balance=0): self.account_number = account_number # Public self.__balance = initial_balance # Private! self.__transaction_log = [] # Private transaction history def deposit(self, amount): """Only way to add money""" if amount <= 0: raise ValueError('Deposit amount must be positive') self.__balance += amount self.__transaction_log.append(f'Deposited: ₹{amount}') print(f'Deposited ₹{amount}. New balance: ₹{self.__balance}') def withdraw(self, amount): """Only way to remove money - with validation""" if amount <= 0: raise ValueError('Withdrawal amount must be positive') if amount > self.__balance: raise ValueError(f'Insufficient funds. Balance: ₹{self.__balance}') self.__balance -= amount self.__transaction_log.append(f'Withdrew: ₹{amount}') print(f'Withdrew ₹{amount}. New balance: ₹{self.__balance}') def get_balance(self): """Read-only access to balance""" return self.__balance def get_statement(self): """View transaction history""" print(f'\nAccount: {self.account_number}') print(f'Balance: ₹{self.__balance}') print('\nTransactions:') for txn in self.__transaction_log: print(f' {txn}') # Usage account = BankAccount('HDFC123456', 10000) # This works - public interface account.deposit(5000) # Deposited ₹5000. New balance: ₹15000 account.withdraw(3000) # Withdrew ₹3000. New balance: ₹12000 print(f'Balance: ₹{account.get_balance()}') # ₹12000 # This FAILS - can't access private attribute try: print(account.__balance) except AttributeError as e: print(f'Error: {e}') # 'BankAccount' object has no attribute '__balance' # This also FAILS - can't manipulate balance directly try: account.__balance = 1000000 # Try to make yourself rich! except: pass # Balance unchanged - encapsulation protected it! print(f'Balance still: ₹{account.get_balance()}') # ₹12000 # Private attributes enforced through methods - security!3b:T6f8,class Temperature: """Temperature with automatic Celsius/Fahrenheit conversion""" def __init__(self, celsius=0): self.__celsius = celsius # Private storage @property def celsius(self): """Get temperature in Celsius""" return self.__celsius @celsius.setter def celsius(self, value): """Set temperature in Celsius with validation""" if value < -273.15: raise ValueError('Temperature below absolute zero!') self.__celsius = value @property def fahrenheit(self): """Computed property: calculate from celsius""" return (self.__celsius * 9/5) + 32 @fahrenheit.setter def fahrenheit(self, value): """Set via Fahrenheit, store as Celsius""" celsius = (value - 32) * 5/9 if celsius < -273.15: raise ValueError('Temperature below absolute zero!') self.__celsius = celsius @property def kelvin(self): """Another computed property""" return self.__celsius + 273.15 # Usage - looks like attributes, acts like methods! temp = Temperature(25) print(f'Celsius: {temp.celsius}') # 25 (calls getter) print(f'Fahrenheit: {temp.fahrenheit}') # 77.0 (computed!) print(f'Kelvin: {temp.kelvin}') # 298.15 (computed!) # Set via property - validation runs temp.celsius = 100 print(f'Boiling: {temp.fahrenheit}') # 212.0 # Set via Fahrenheit - converts and validates temp.fahrenheit = 32 print(f'Freezing: {temp.celsius}') # 0.0 # Validation prevents invalid values try: temp.celsius = -300 # Below absolute zero! except ValueError as e: print(f'Error: {e}') # Temperature below absolute zero! # Clean syntax: temp.celsius = 50 # Not ugly: temp.set_celsius(50) # This is Pythonic!3c:T995,import re class User: """User with validated email and computed properties""" def __init__(self, username, email): self.username = username self.__email = None # Private storage self.email = email # Calls setter for validation self.__login_count = 0 @property def email(self): """Get email""" return self.__email @email.setter def email(self, value): """Validate email format before setting""" if not value or '@' not in value: raise ValueError('Invalid email format') # More thorough validation pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' if not re.match(pattern, value): raise ValueError(f'Invalid email: {value}') self.__email = value.lower() # Store lowercase @property def domain(self): """Computed property: extract domain from email""" if self.__email: return self.__email.split('@')[1] return None @property def is_corporate(self): """Computed property: check if corporate email""" corporate_domains = ['company.com', 'enterprise.com', 'corp.com'] return self.domain in corporate_domains @property def login_count(self): """Read-only property - no setter!""" return self.__login_count def login(self): """Increment login count""" self.__login_count += 1 print(f'{self.username} logged in (total: {self.__login_count})') # Usage user = User('raj_kumar', 'raj@gmail.com') print(f'Email: {user.email}') # raj@gmail.com print(f'Domain: {user.domain}') # gmail.com (computed!) print(f'Corporate: {user.is_corporate}') # False # Validation in action try: user.email = 'invalid-email' # No @ except ValueError as e: print(f'Error: {e}') try: user.email = 'bad@' # Invalid format except ValueError as e: print(f'Error: {e}') # Valid email user.email = 'raj@company.com' print(f'Domain: {user.domain}') # company.com print(f'Corporate: {user.is_corporate}') # True # Read-only property user.login() user.login() print(f'Logins: {user.login_count}') # 2 # Can't set login_count directly - it's read-only! try: user.login_count = 100 # AttributeError except AttributeError as e: print(f'Error: Cannot set read-only property') # This is how Django User model validates emails3d:Td09,from datetime import datetime class BankAccount: """Production-ready bank account""" def __init__(self, owner, account_number, initial_balance=0): self.owner = owner self.account_number = account_number self.__balance = initial_balance # Private! self.__transactions = [] self.__is_frozen = False @property def balance(self): """Read-only balance - cannot be set directly!""" return self.__balance @property def is_frozen(self): """Account frozen status""" return self.__is_frozen @property def transactions(self): """Read-only transaction history""" # Return copy to prevent modification return self.__transactions.copy() @property def last_transaction(self): """Computed: most recent transaction""" return self.__transactions[-1] if self.__transactions else None @property def account_age_days(self): """Computed: days since first transaction""" if not self.__transactions: return 0 first = self.__transactions[0]['timestamp'] return (datetime.now() - first).days def deposit(self, amount): """Only way to increase balance""" if self.__is_frozen: raise ValueError('Account is frozen') if amount <= 0: raise ValueError('Deposit must be positive') self.__balance += amount self.__transactions.append({ 'type': 'deposit', 'amount': amount, 'timestamp': datetime.now(), 'balance_after': self.__balance }) def withdraw(self, amount): """Only way to decrease balance""" if self.__is_frozen: raise ValueError('Account is frozen') if amount <= 0: raise ValueError('Withdrawal must be positive') if amount > self.__balance: raise ValueError('Insufficient funds') self.__balance -= amount self.__transactions.append({ 'type': 'withdraw', 'amount': amount, 'timestamp': datetime.now(), 'balance_after': self.__balance }) def freeze(self): """Freeze account (fraud protection)""" self.__is_frozen = True def unfreeze(self): """Unfreeze account""" self.__is_frozen = False # Usage account = BankAccount('Raj Kumar', 'HDFC123456', 10000) # Properties give clean access print(f'Balance: ₹{account.balance}') # Read-only property print(f'Frozen: {account.is_frozen}') # Read-only property # Deposit via method account.deposit(5000) account.withdraw(2000) # Properties compute values print(f'Balance: ₹{account.balance}') # 13000 print(f'Transactions: {len(account.transactions)}') # 2 print(f'Last: {account.last_transaction["type"]}') # withdraw # Can't manipulate balance directly! try: account.balance = 1000000 # Try to get rich except AttributeError: print('Cannot set balance directly - protected!') # Frozen account account.freeze() print(f'Frozen: {account.is_frozen}') # True try: account.withdraw(1000) # Blocked! except ValueError as e: print(f'Error: {e}') # Account is frozen # This is how real banking apps protect accounts3e:T769,# Example: Rectangle class - different approaches # APPROACH 1: All public - RISKY class RectangleBad: def __init__(self, width, height): self.width = width # Public self.height = height # Public self.area = width * height # Public, pre-computed # Problem: area can become inconsistent! rect = RectangleBad(10, 5) print(rect.area) # 50 rect.width = 20 # Change width print(rect.area) # Still 50! Inconsistent! # APPROACH 2: All private with getters/setters - OVERKILL class RectangleOverkill: def __init__(self, width, height): self.__width = width self.__height = height def get_width(self): return self.__width def set_width(self, width): self.__width = width def get_height(self): return self.__height def set_height(self, height): self.__height = height def get_area(self): return self.__width * self.__height # Ugly syntax rect = RectangleOverkill(10, 5) print(rect.get_area()) # Verbose! rect.set_width(20) # Not Pythonic # APPROACH 3: Pythonic encapsulation - JUST RIGHT class Rectangle: """Well-encapsulated rectangle""" def __init__(self, width, height): self.width = width # Public - simple, no invariants self.height = height # Public - simple, no invariants @property def area(self): """Computed property - always consistent!""" return self.width * self.height @property def perimeter(self): """Another computed property""" return 2 * (self.width + self.height) # Clean syntax, always consistent rect = Rectangle(10, 5) print(f'Area: {rect.area}') # 50 rect.width = 20 print(f'Area: {rect.area}') # 100 - automatically updated! print(f'Perimeter: {rect.perimeter}') # 50 # Simple attributes public, computed values as properties # This is Pythonic!3f:T9e5,# Invariant: condition that must always be true class DateRange: """Date range where start must be before end""" def __init__(self, start, end): # Private storage self.__start = None self.__end = None # Use setters for validation self.start = start self.end = end @property def start(self): return self.__start @start.setter def start(self, value): # Invariant: start must be before end if self.__end and value > self.__end: raise ValueError('Start must be before end') self.__start = value @property def end(self): return self.__end @end.setter def end(self, value): # Invariant: end must be after start if self.__start and value < self.__start: raise ValueError('End must be after start') self.__end = value @property def duration_days(self): """Computed: days between start and end""" return (self.__end - self.__start).days from datetime import date # Valid range dr = DateRange(date(2025, 1, 1), date(2025, 1, 31)) print(f'Duration: {dr.duration_days} days') # 30 # Try to violate invariant try: dr.start = date(2025, 2, 1) # After end! except ValueError as e: print(f'Error: {e}') # Start must be before end # Invariant protected by encapsulation # Without properties, nothing stops: dr.start = invalid_date # Production example: Temperature range class TemperatureRange: """Min must be ≤ max""" def __init__(self, min_temp, max_temp): self.__min = None self.__max = None self.min_temp = min_temp self.max_temp = max_temp @property def min_temp(self): return self.__min @min_temp.setter def min_temp(self, value): if self.__max and value > self.__max: raise ValueError('Min must be ≤ max') self.__min = value @property def max_temp(self): return self.__max @max_temp.setter def max_temp(self, value): if self.__min and value < self.__min: raise ValueError('Max must be ≥ min') self.__max = value @property def range(self): return self.__max - self.__min tr = TemperatureRange(20, 30) print(f'Range: {tr.range}°C') # 10°C # Protected! try: tr.max_temp = 10 # Less than min except ValueError as e: print(f'Error: {e}') # Max must be ≥ min # Encapsulation enforces business rules40:T9cb,# Properties enable refactoring without breaking code # VERSION 1: Simple attribute class User_v1: def __init__(self, name): self.name = name # Public attribute # Client code user = User_v1('Raj Kumar') print(user.name) # Works user.name = 'Priya Sharma' # Works # VERSION 2: Need to split name into first/last # Can't change from 'name' to 'first_name'/'last_name' - breaks existing code! # Solution: Properties! class User_v2: def __init__(self, name): # Store as first/last internally parts = name.split(' ', 1) self.__first_name = parts[0] self.__last_name = parts[1] if len(parts) > 1 else '' @property def name(self): """Backwards compatible: still works like attribute""" return f'{self.__first_name} {self.__last_name}'.strip() @name.setter def name(self, value): """Backwards compatible: still can assign""" parts = value.split(' ', 1) self.__first_name = parts[0] self.__last_name = parts[1] if len(parts) > 1 else '' @property def first_name(self): """New API: direct first name access""" return self.__first_name @property def last_name(self): """New API: direct last name access""" return self.__last_name # Old code still works! user = User_v2('Raj Kumar') print(user.name) # Raj Kumar - works! user.name = 'Priya Sharma' # Works! # New code can use new API print(user.first_name) # Priya print(user.last_name) # Sharma # Implementation changed, interface stayed same! # This is how Django User evolved without breaking millions of apps # Another example: Temperature storage change class Temperature_v1: def __init__(self, celsius): self.celsius = celsius # Store celsius class Temperature_v2: def __init__(self, celsius): # Changed internal storage to Kelvin for scientific accuracy self.__kelvin = celsius + 273.15 @property def celsius(self): """Backwards compatible: still accessible as celsius""" return self.__kelvin - 273.15 @celsius.setter def celsius(self, value): """Backwards compatible: still settable""" self.__kelvin = value + 273.15 # Old code unchanged temp = Temperature_v2(25) print(temp.celsius) # 25 - works! temp.celsius = 100 print(temp.celsius) # 100 - works! # Internally stores Kelvin, externally looks like Celsius # Properties enable evolution without breaking compatibility41:T8f3,class BankAccount: """Secure bank account - balance is private""" def __init__(self, account_number, initial_balance=0): self.account_number = account_number # Public self.__balance = initial_balance # Private! self.__transaction_log = [] # Private transaction history def deposit(self, amount): """Only way to add money""" if amount <= 0: raise ValueError('Deposit amount must be positive') self.__balance += amount self.__transaction_log.append(f'Deposited: ₹{amount}') print(f'Deposited ₹{amount}. New balance: ₹{self.__balance}') def withdraw(self, amount): """Only way to remove money - with validation""" if amount <= 0: raise ValueError('Withdrawal amount must be positive') if amount > self.__balance: raise ValueError(f'Insufficient funds. Balance: ₹{self.__balance}') self.__balance -= amount self.__transaction_log.append(f'Withdrew: ₹{amount}') print(f'Withdrew ₹{amount}. New balance: ₹{self.__balance}') def get_balance(self): """Read-only access to balance""" return self.__balance def get_statement(self): """View transaction history""" print(f'\nAccount: {self.account_number}') print(f'Balance: ₹{self.__balance}') print('\nTransactions:') for txn in self.__transaction_log: print(f' {txn}') # Usage account = BankAccount('HDFC123456', 10000) # This works - public interface account.deposit(5000) # Deposited ₹5000. New balance: ₹15000 account.withdraw(3000) # Withdrew ₹3000. New balance: ₹12000 print(f'Balance: ₹{account.get_balance()}') # ₹12000 # This FAILS - can't access private attribute try: print(account.__balance) except AttributeError as e: print(f'Error: {e}') # 'BankAccount' object has no attribute '__balance' # This also FAILS - can't manipulate balance directly try: account.__balance = 1000000 # Try to make yourself rich! except: pass # Balance unchanged - encapsulation protected it! print(f'Balance still: ₹{account.get_balance()}') # ₹12000 # Private attributes enforced through methods - security!29:["$","div",null,{"className":"min-h-screen bg-gray-50 dark:bg-gray-900 pt-20","children":[["$","$L37",null,{"topicSlug":"python","topicTitle":"Python Engineer's Expedition","dayNumber":40,"dayTitle":"Encapsulation: Protecting Your Data","sprintNumber":2,"estimatedTime":"90-120 minutes","totalDays":66}],["$","div",null,{"className":"w-full px-4 sm:px-6 lg:px-8 py-8","children":["$","$L38",null,{"dayNumber":40,"topicSlug":"python","children":["$","$L39",null,{"day":{"dayNumber":40,"sprintNumber":2,"title":"Encapsulation: Protecting Your Data","subtitle":"Control access with private attributes and properties","description":"Master encapsulation to build secure, maintainable classes. Learn how banking apps protect account balances and how frameworks use properties for validation.","slug":"encapsulation-properties","week":6,"duration":"90-120 minutes","lastUpdated":"2025-11-30","learningGoals":[{"id":"goal-40-1","text":"Create private attributes with __ prefix","measurable":"Build BankAccount with __balance that can't be accessed directly"},{"id":"goal-40-2","text":"Use @property decorator for controlled access","measurable":"Create User class with validated email property"},{"id":"goal-40-3","text":"Implement getters and setters","measurable":"Build Temperature class converting Celsius/Fahrenheit via properties"},{"id":"goal-40-4","text":"Design encapsulated classes for security","measurable":"Create SecurePassword class that hashes passwords, never stores plain text"}],"whyThisMatters":{"productionStory":"HDFC Bank's mobile app handles ₹50,000 crore daily. Your account balance? Encapsulated in BankAccount class with private __balance. You can't do account.__balance = 1000000 to make yourself rich. The only way to change balance is through validated methods: deposit(), withdraw(), transfer(). Each checks permissions, logs transactions, updates database. Without encapsulation, one bug could let users modify any variable, causing catastrophic losses. Encapsulation is how financial systems maintain security and data integrity. It's not a nice-to-have - it's how banks prevent fraud and bugs from destroying customer accounts.","realWorldContext":"Every password system uses encapsulation. User class has private __password_hash. You never see actual password. System validates via check_password() method. ORM libraries (Django ORM) encapsulate database queries - you never write SQL directly. Game engines encapsulate physics - you don't manipulate velocity directly, you call apply_force(). Encapsulation separates interface from implementation. Change implementation, interface stays same. This is how codebases survive for decades.","industryRelevance":"Code reviews check encapsulation. Public attributes that should be private? Rejected. Direct manipulation of internal state? Rejected. 'Information hiding' is core OOP principle. Senior engineers design clean boundaries. Django models use properties for computed fields. Frameworks rely on encapsulation for backwards compatibility."},"missionAlignment":{"ourMission":"Learn Today teaches production patterns. Encapsulation isn't theory - it's how banking apps, auth systems, and frameworks protect data integrity.","thisLesson":"Today you learn why bank apps don't let you edit balance directly. Why password systems never expose passwords. Real security patterns used by billion-dollar systems.","yourGrowth":"You're learning defensive programming. Not just making code work - making it impossible to misuse. This separates junior from senior engineers."},"coreValues":{"clarity":"We explain encapsulation through real security needs: banking, passwords, medical records. Not academic theory.","practicality":"Every example from production: BankAccount (banking), User (auth), Temperature (scientific), SecurePassword (security).","depth":"We teach name mangling, @property mechanics, when to use properties vs methods. Deep understanding of access control.","empowerment":"By end of day: design secure classes, prevent data corruption, build maintainable APIs. You're thinking about security and data integrity."},"coreContent":{"sections":[{"id":"section-1","type":"concept","title":"Private Attributes: Protecting Internal State","order":1,"content":{"explanation":"Encapsulation means bundling data and methods, then controlling access. Use __ (double underscore) prefix for private attributes. Python name-mangles them to _ClassName__attribute, making accidental access difficult. Not true privacy (Python philosophy: 'we're all consenting adults'), but clear signal: 'This is internal, don't touch.' Public interface through methods.","keyPoints":["Private attributes: __variable (double underscore)","Name mangling: __balance becomes _BankAccount__balance","Single underscore _variable: internal convention, not enforced","Public methods control access to private data","Encapsulation prevents direct manipulation, ensures validity"],"codeExamples":[{"title":"Banking: Secure Account Balance","code":"$3a","language":"python","explanation":"__balance is private. Can't access account.__balance or set it directly. Only way to change balance is through deposit()/withdraw() which validate inputs, log transactions, maintain integrity. This is how banking apps prevent balance manipulation."}],"productionContext":"Django ORM: model fields are often private, accessed via properties. Payment gateways: card details private, only accessed through secure methods. Medical systems: patient data private, HIPAA compliance through encapsulation."}},{"id":"section-2","type":"concept","title":"@property Decorator: Pythonic Getters and Setters","order":2,"content":{"explanation":"Java/C++ use explicit getters/setters: getBalance(), setBalance(). Python has @property decorator - looks like attribute access, acts like method. user.email looks like direct access, but actually calls method that can validate, compute, log. Best of both worlds: clean syntax + controlled access. Properties enable: validation on set, computation on get, read-only attributes, backwards compatibility (turn attribute into property without breaking code).","keyPoints":["@property: method that acts like attribute","getter: @property def attribute(self)","setter: @attribute.setter def attribute(self, value)","Read-only: property without setter","Computed properties: calculate value on access","Validation: enforce rules in setter"],"codeExamples":[{"title":"Temperature with Validation","code":"$3b","language":"python","explanation":"Properties give clean syntax with validation. temp.celsius = 100 looks like direct assignment, but setter validates value. fahrenheit is computed from celsius - no separate storage needed. This is how scientific libraries (like NumPy units) handle conversions."},{"title":"User with Email Validation","code":"$3c","language":"python","explanation":"Email property validates format on set. domain and is_corporate are computed - no separate storage. login_count is read-only - has getter but no setter. Properties enable validation, computation, and access control with clean syntax. Django User model uses properties extensively."},{"title":"BankAccount with Properties","code":"$3d","language":"python","explanation":"balance, is_frozen, transactions are read-only properties. last_transaction and account_age_days are computed. Can't do account.balance = 99999 - AttributeError. Must use deposit()/withdraw() which validate, log, enforce business rules. This is production security pattern used by banking apps."}],"productionContext":"Django models: properties for computed fields (full_name from first+last). SQLAlchemy: hybrid_property for database-backed properties. Pandas: computed properties on DataFrames. Properties are everywhere in production Python."}},{"id":"section-3","type":"concept","title":"Encapsulation Patterns: When and Why","order":3,"content":{"explanation":"Not everything should be private. Encapsulation is about hiding complexity and protecting invariants, not hiding everything. Public attributes are fine if they don't need validation or computation. Use private (__) for: internal implementation details, data that must stay consistent, security-sensitive info. Use properties for: validated attributes, computed values, read-only access. Keep public: simple attributes with no invariants. Good encapsulation enables refactoring - change implementation without breaking interface.","keyPoints":["Not everything needs to be private","Private (__): implementation details, must-stay-consistent data","Properties: validation, computation, read-only access","Public: simple attributes, no invariants","Good encapsulation: change implementation, keep interface","Interface vs implementation: separate what from how"],"codeExamples":[{"title":"When to Use Each Approach","code":"$3e","language":"python","explanation":"RectangleBad: area can become stale. RectangleOverkill: unnecessary getters/setters. Rectangle: width/height public (simple values), area/perimeter computed (always consistent). Use encapsulation where it adds value, not everywhere."},{"title":"Protecting Invariants with Encapsulation","code":"$3f","language":"python","explanation":"Invariant: start < end always. Properties enforce this - can't set start > end or end < start. Without encapsulation, nothing prevents invalid state. DateRange uses encapsulation to guarantee consistency. This is how libraries ensure correctness."},{"title":"Backwards Compatibility with Properties","code":"$40","language":"python","explanation":"User_v2 changed internal storage (first_name/last_name) but kept name property working. Old code unchanged, new features available. This is how mature libraries evolve - properties maintain backwards compatibility while refactoring internals. Django, Flask, pandas use this pattern extensively."}],"productionContext":"Django models evolved over 15 years using properties for backwards compatibility. NumPy changed internal storage formats without breaking user code. AWS SDK: private implementation, stable public API. Encapsulation enables evolution."}},{"id":"section-4","type":"visual-learning","title":"Video Learning Paths","order":4,"content":{"explanation":"Curated video to master encapsulation and property decorators from expert instructors.","keyPoints":["Video covers Day 40 concepts comprehensively","Watch to reinforce learning with visual examples","Corey Schafer's property decorator tutorial is essential viewing"]},"videoResources":[{"title":"Python OOP Tutorial 6: Property Decorators - Getters, Setters, and Deleters","creator":"Corey Schafer","embedId":"jCzT9XFZ5bw","duration":"9:33","description":"⭐ ESSENTIAL. Corey explains @property decorator with Employee email example. Shows getter/setter/deleter pattern with crystal clear explanations. This is THE definitive property decorator tutorial.","when":"Watch after reading sections 1-3 to see property decorators in action. Must watch for mastering encapsulation."}]}]},"challenges":[{"id":"challenge-40-1","difficulty":"basecamp","title":"Temperature Converter with Properties","description":"Create Temperature class with Celsius/Fahrenheit conversion via properties","instructions":["Temperature class stores celsius as private __celsius","@property celsius getter returns celsius value","@celsius.setter validates celsius >= -273.15 (absolute zero)","@property fahrenheit calculates from celsius","@fahrenheit.setter converts and stores as celsius","Test both getter and setter for each property"],"starterCode":"class Temperature:\n def __init__(self, celsius=0):\n # Private attribute\n pass\n \n @property\n def celsius(self):\n # Getter\n pass\n \n @celsius.setter\n def celsius(self, value):\n # Validate and set\n pass\n \n @property\n def fahrenheit(self):\n # Calculate from celsius\n pass\n \n @fahrenheit.setter\n def fahrenheit(self, value):\n # Convert to celsius and set\n pass\n\n# Test\ntemp = Temperature(25)\nprint(f'Celsius: {temp.celsius}')\nprint(f'Fahrenheit: {temp.fahrenheit}')\ntemp.fahrenheit = 100\nprint(f'Celsius: {temp.celsius}')","hints":["Fahrenheit = (Celsius × 9/5) + 32","Celsius = (Fahrenheit - 32) × 5/9","Raise ValueError if temperature below absolute zero","Properties make API clean: temp.celsius = 30"]},{"id":"challenge-40-2","difficulty":"ridge","title":"Secure Bank Account","description":"Build BankAccount with private balance and controlled access","instructions":["Private __balance attribute","@property balance getter (read-only)","deposit(amount) validates amount > 0","withdraw(amount) checks sufficient funds","Private __transaction_history list","@property transaction_history getter (read-only)","All transactions logged automatically"],"starterCode":"from datetime import datetime\n\nclass BankAccount:\n def __init__(self, owner, initial_balance=0):\n self.owner = owner\n # Private attributes\n pass\n \n @property\n def balance(self):\n # Read-only balance\n pass\n \n @property\n def transaction_history(self):\n # Read-only history\n pass\n \n def deposit(self, amount):\n # Validate and deposit\n # Log transaction\n pass\n \n def withdraw(self, amount):\n # Validate and withdraw\n # Log transaction\n pass\n\n# Test\naccount = BankAccount('Raj', 10000)\naccount.deposit(5000)\naccount.withdraw(3000)\nprint(f'Balance: ₹{account.balance}')\nprint('Transaction History:')\nfor trans in account.transaction_history:\n print(f' {trans}')","hints":["balance has getter only - no setter (immutable)","Can't do account.balance = 999999 - protected!","Log: {'type': 'deposit', 'amount': 5000, 'time': datetime.now()}","This is how real banking apps protect data"]},{"id":"challenge-40-3","difficulty":"summit","title":"User Authentication System","description":"Build complete user system with password hashing and validation","instructions":["User class with username and private __password_hash","set_password() hashes password before storing (use hashlib)","check_password() verifies password against hash","@property email with validation (must contain @)","@property is_valid checks if user has username and email","Never store plain text passwords!"],"starterCode":"import hashlib\n\nclass User:\n def __init__(self, username):\n self.username = username\n # Private attributes\n pass\n \n def set_password(self, password):\n # Hash and store\n # hash = hashlib.sha256(password.encode()).hexdigest()\n pass\n \n def check_password(self, password):\n # Verify password\n pass\n \n @property\n def email(self):\n # Getter\n pass\n \n @email.setter\n def email(self, value):\n # Validate @ symbol\n pass\n \n @property\n def is_valid(self):\n # Check username and email exist\n pass","hints":["Never print or return __password_hash directly","Hash both passwords when checking","Validate email contains @ symbol","This is how Django authenticates users"]}],"practiceProjects":[{"title":"Banking System with Encapsulation","difficulty":"advanced","estimatedTime":"60-90 minutes","description":"Build complete banking system with SavingsAccount, CheckingAccount, proper encapsulation, transaction logging"}],"commonPitfalls":[{"id":"pitfall-40-1","title":"Making everything private unnecessarily","example":"# Overzealous privacy\nclass Person:\n def __init__(self, name):\n self.__name = name # Why private? Name is fine to access!","howToFix":["Use private only for data that needs protection","Public by default, private when necessary"],"whyItHappens":"Misunderstanding encapsulation as 'hide everything'"}],"connections":{"previous":{"content":"Day 39: Polymorphism. Today: Encapsulation for security.","prerequisites":"Classes, methods"},"current":{"keyTakeaways":["Private attributes with __","@property for controlled access","Getters/setters for validation","Encapsulation prevents corruption"]},"next":{"preview":"Tomorrow: Special methods (__str__, __repr__, __eq__)","teaser":"Make your classes work with print(), len(), + operator like built-ins."}},"reflectionQuestions":[{"id":"reflect-40-1","question":"When should attributes be private vs public?","purpose":"Design judgment"},{"id":"reflect-40-2","question":"How does encapsulation improve security in banking systems?","purpose":"Real-world application"}],"tomorrowPreview":{"hook":"Encapsulation protects data. Tomorrow: Special methods make classes Pythonic.","teaser":"print(account) shows account details. len(cart) returns item count. account1 + account2 merges accounts. Magic methods!","curiosityQuestion":"How do built-in types (list, dict, str) work with print(), len(), +? Can your classes do the same?"},"metadata":{"estimatedTime":"90-120 minutes","topics":["Encapsulation","Private Attributes","Property Decorators","Getters/Setters","Data Protection"],"difficulty":"intermediate","prerequisites":["day-37","day-38"]}},"topicSlug":"python","navigation":{"previous":{"dayNumber":39,"title":"Polymorphism: One Interface, Many Forms","sprintNumber":2},"next":{"dayNumber":41,"title":"Special Methods: Making Classes Pythonic","sprintNumber":2}},"dayNumber":40,"totalDays":66,"mathEnabled":false,"starterCode":"$41"}]}]}]]}]