🚀 Day 68: Dive deep into Python's hidden gems! Today, we're unmasking **Descriptors**! ✨ These aren't just fancy `property` alternatives; they're powerful mechanisms enabling self-configuring attributes, proxy objects, and much more. Ever wondered how `property`, `staticmethod`, or `classmethod` work under the hood? It's all about descriptors! Get ready to elevate your Python architectural skills. Let's craft some magic! 🎩
```python
import numbers
class PositiveInteger:
"""
A descriptor that ensures an attribute is a positive integer.
"""
def __set_name__(self, owner, name):
# Called automatically when the descriptor is assigned to a class attribute.
self.public_name = name
self.private_name = '_' + name # Store value in a private attribute
def __get__(self, obj, objtype=None):
if obj is None:
# Accessing descriptor from the class (e.g., Product.price)
return self
# Accessing descriptor from an instance (e.g., product1.price)
return getattr(obj, self.private_name)
def __set__(self, obj, value):
# Called when setting the attribute (e.g., product1.price = 100)
if not isinstance(value, numbers.Integral):
raise TypeError(f'Attribute "{self.public_name}" must be an integer.')
if value <= 0:
raise ValueError(f'Attribute "{self.public_name}" must be positive.')
setattr(obj, self.private_name, value)
def __delete__(self, obj):
# Called when deleting the attribute (e.g., del product1.price)
delattr(obj, self.private_name)
class Product:
price = PositiveInteger()
quantity = PositiveInteger()
def __init__(self, name, price, quantity):
self.name = name
self.price = price # Uses the descriptor's __set__
self.quantity = quantity # Uses the descriptor's __set__
def display_info(self):
print(f"Product: {self.name}, Price: ${self.price}, Quantity: {self.quantity}")
# --- Demonstration ---
print("--- Valid Product ---")
product1 = Product("Laptop", 1200, 5)
product1.display_info()
print(f"Initial price: {product1.price}")
print("n--- Modifying price (valid) ---")
product1.price = 1250
print(f"New price: {product1.price}")
print("n--- Trying invalid price (negative) ---")
try:
product1.price = -100
except ValueError as e:
print(f"Error: {e}")
print("n--- Trying invalid quantity (non-integer) ---")
try:
product2 = Product("Mouse", 25, 2.5)
except TypeError as e:
print(f"Error: {e}")
print("n--- Accessing descriptor from class ---")
print(f"Product.price is a {type(Product.price).__name__} object.")
```
Output example:
```
--- Valid Product ---
Product: Laptop, Price: $1200, Quantity: 5
Initial price: 1200
--- Modifying price (valid) ---
New price: 1250
--- Trying invalid price (negative) ---
Error: Attribute "price" must be positive.
--- Trying invalid quantity (non-integer) ---
Error: Attribute "quantity" must be an integer.
--- Accessing descriptor from class ---
Product.price is a PositiveInteger object.
```
💡 **Your Challenge:** Modify the `PositiveInteger` descriptor to also accept an optional `min_value` and `max_value` during its instantiation (e.g., `price = BoundedInteger(min_value=1, max_value=5000)`). How would you store and use these bounds within the descriptor? Share your solution! 👇
```python
import numbers
class PositiveInteger:
"""
A descriptor that ensures an attribute is a positive integer.
"""
def __set_name__(self, owner, name):
# Called automatically when the descriptor is assigned to a class attribute.
self.public_name = name
self.private_name = '_' + name # Store value in a private attribute
def __get__(self, obj, objtype=None):
if obj is None:
# Accessing descriptor from the class (e.g., Product.price)
return self
# Accessing descriptor from an instance (e.g., product1.price)
return getattr(obj, self.private_name)
def __set__(self, obj, value):
# Called when setting the attribute (e.g., product1.price = 100)
if not isinstance(value, numbers.Integral):
raise TypeError(f'Attribute "{self.public_name}" must be an integer.')
if value <= 0:
raise ValueError(f'Attribute "{self.public_name}" must be positive.')
setattr(obj, self.private_name, value)
def __delete__(self, obj):
# Called when deleting the attribute (e.g., del product1.price)
delattr(obj, self.private_name)
class Product:
price = PositiveInteger()
quantity = PositiveInteger()
def __init__(self, name, price, quantity):
self.name = name
self.price = price # Uses the descriptor's __set__
self.quantity = quantity # Uses the descriptor's __set__
def display_info(self):
print(f"Product: {self.name}, Price: ${self.price}, Quantity: {self.quantity}")
# --- Demonstration ---
print("--- Valid Product ---")
product1 = Product("Laptop", 1200, 5)
product1.display_info()
print(f"Initial price: {product1.price}")
print("n--- Modifying price (valid) ---")
product1.price = 1250
print(f"New price: {product1.price}")
print("n--- Trying invalid price (negative) ---")
try:
product1.price = -100
except ValueError as e:
print(f"Error: {e}")
print("n--- Trying invalid quantity (non-integer) ---")
try:
product2 = Product("Mouse", 25, 2.5)
except TypeError as e:
print(f"Error: {e}")
print("n--- Accessing descriptor from class ---")
print(f"Product.price is a {type(Product.price).__name__} object.")
```
Output example:
```
--- Valid Product ---
Product: Laptop, Price: $1200, Quantity: 5
Initial price: 1200
--- Modifying price (valid) ---
New price: 1250
--- Trying invalid price (negative) ---
Error: Attribute "price" must be positive.
--- Trying invalid quantity (non-integer) ---
Error: Attribute "quantity" must be an integer.
--- Accessing descriptor from class ---
Product.price is a PositiveInteger object.
```
💡 **Your Challenge:** Modify the `PositiveInteger` descriptor to also accept an optional `min_value` and `max_value` during its instantiation (e.g., `price = BoundedInteger(min_value=1, max_value=5000)`). How would you store and use these bounds within the descriptor? Share your solution! 👇
What special methods must a class implement to function as a data descriptor in Python, affecting both attribute reading and writing?
Anonymous Quiz
0%
`__get__` and `__set__`
0%
`__getattr__` and `__setattr__`
0%
`__getitem__` and `__setitem__`
0%
`__call__` and `__init__`
Hey Pythonistas! 👋 Ready to unlock a deeper understanding of how Python truly works?
On Day 69 of our deep-dive series, we're venturing into the compiler's lair! 🤯 We'll be **Deconstructing the AST: Building Compiler-Level Tools and Runtime Code Transformers**. Ever wondered how linters, static analyzers, or even IDEs understand your code? It's all thanks to the Abstract Syntax Tree (AST) – Python's internal, structured representation of your code. By learning to inspect, traverse, and even modify this tree, you gain immense power for custom static analysis, code generation, and runtime transformations. Let's peek under the hood! 🕵️♀️
```python
import ast
code_snippet = """
def calculate_discount(price, discount_percentage):
# This function calculates the discounted price.
if price > 100 and discount_percentage > 0.1:
discount_amount = price * discount_percentage
final_price = price - discount_amount
return final_price
else:
return price
"""
class ASTInspector(ast.NodeVisitor):
"""
A simple AST visitor to inspect function definitions, assignments,
and conditional statements within our code snippet.
"""
def visit_FunctionDef(self, node):
print(f"➡️ Function: '{node.name}' declared on line {node.lineno}")
self.generic_visit(node) # Important: visit children nodes too
def visit_Assign(self, node):
targets = [t.id for t in node.targets if isinstance(t, ast.Name)]
print(f" 📝 Assignment to '{', '.join(targets)}' on line {node.lineno}")
self.generic_visit(node)
def visit_If(self, node):
print(f" ❓ If statement starts on line {node.lineno}")
self.generic_visit(node)
def visit_Constant(self, node):
# We can even see literal values!
if isinstance(node.value, (int, float, str, bool, type(None))):
print(f" 🌟 Constant value: {repr(node.value)} on line {node.lineno}")
self.generic_visit(node)
# 1. Parse the code into an AST
tree = ast.parse(code_snippet)
# 2. Inspect the AST using our custom visitor
print("--- Beginning AST Inspection ---")
ASTInspector().visit(tree)
print("--- End AST Inspection ---")
```
Output example:
```
--- Beginning AST Inspection ---
➡️ Function: 'calculate_discount' declared on line 2
❓ If statement starts on line 4
🌟 Constant value: 100 on line 4
🌟 Constant value: 0.1 on line 4
📝 Assignment to 'discount_amount' on line 5
📝 Assignment to 'final_price' on line 6
❓ If statement starts on line 4
--- End AST Inspection ---
```
Challenge for today:
Modify the `ASTInspector` to count how many `ast.BinOp` (binary operations like `+`, `-`, `*`, `/`) nodes are present within the `calculate_discount` function. Hint: you'll need a `visit_BinOp` method and a counter! Good luck, ASTronaut! 🚀
---
On Day 69 of our deep-dive series, we're venturing into the compiler's lair! 🤯 We'll be **Deconstructing the AST: Building Compiler-Level Tools and Runtime Code Transformers**. Ever wondered how linters, static analyzers, or even IDEs understand your code? It's all thanks to the Abstract Syntax Tree (AST) – Python's internal, structured representation of your code. By learning to inspect, traverse, and even modify this tree, you gain immense power for custom static analysis, code generation, and runtime transformations. Let's peek under the hood! 🕵️♀️
```python
import ast
code_snippet = """
def calculate_discount(price, discount_percentage):
# This function calculates the discounted price.
if price > 100 and discount_percentage > 0.1:
discount_amount = price * discount_percentage
final_price = price - discount_amount
return final_price
else:
return price
"""
class ASTInspector(ast.NodeVisitor):
"""
A simple AST visitor to inspect function definitions, assignments,
and conditional statements within our code snippet.
"""
def visit_FunctionDef(self, node):
print(f"➡️ Function: '{node.name}' declared on line {node.lineno}")
self.generic_visit(node) # Important: visit children nodes too
def visit_Assign(self, node):
targets = [t.id for t in node.targets if isinstance(t, ast.Name)]
print(f" 📝 Assignment to '{', '.join(targets)}' on line {node.lineno}")
self.generic_visit(node)
def visit_If(self, node):
print(f" ❓ If statement starts on line {node.lineno}")
self.generic_visit(node)
def visit_Constant(self, node):
# We can even see literal values!
if isinstance(node.value, (int, float, str, bool, type(None))):
print(f" 🌟 Constant value: {repr(node.value)} on line {node.lineno}")
self.generic_visit(node)
# 1. Parse the code into an AST
tree = ast.parse(code_snippet)
# 2. Inspect the AST using our custom visitor
print("--- Beginning AST Inspection ---")
ASTInspector().visit(tree)
print("--- End AST Inspection ---")
```
Output example:
```
--- Beginning AST Inspection ---
➡️ Function: 'calculate_discount' declared on line 2
❓ If statement starts on line 4
🌟 Constant value: 100 on line 4
🌟 Constant value: 0.1 on line 4
📝 Assignment to 'discount_amount' on line 5
📝 Assignment to 'final_price' on line 6
❓ If statement starts on line 4
--- End AST Inspection ---
```
Challenge for today:
Modify the `ASTInspector` to count how many `ast.BinOp` (binary operations like `+`, `-`, `*`, `/`) nodes are present within the `calculate_discount` function. Hint: you'll need a `visit_BinOp` method and a counter! Good luck, ASTronaut! 🚀
---
Which Python module is primarily used to parse Python source code into an Abstract Syntax Tree (AST)?
Anonymous Quiz
67%
ast
0%
inspect
0%
compiler
33%
sys
What is the primary benefit of `contextvars` over `threading.local` or global variables in modern Python concurrency (e.g., `asyncio`)?
Anonymous Quiz
100%
It provides a more performant way to store data globally across all processes.
0%
It automatically manages context propagation across `asyncio` tasks and compatible thread pools.
0%
It allows for direct low-level manipulation of the CPython interpreter's internal memory.
0%
It enforces strict runtime type checking for all variables stored within its context.
🚀✨ **Day 73: The Reflective Frontier - Metaclasses as Dynamic Code Generators!** ✨🚀
Ever wondered how powerful Python frameworks dynamically generate code or alter class behavior *before* a single instance is even created? Today, we dive deep into Metaclasses! This isn't just about simple class factories; it's about programmatically defining the very blueprints of your classes, injecting methods, properties, or even entire architectural patterns at definition time. Get ready to bend Python to your will and explore true programmatic reflection! 💡
```python
class MetaPropertyCreator(type):
"""
A metaclass that dynamically adds a '_log_creation' method and a
'meta_info' property to any class it creates.
"""
def __new__(mcs, name, bases, dct):
# Dynamically add a method to log instance creation
def _log_creation(self):
print(f"[{name}] Instance created: {self.__dict__}")
dct['_log_creation'] = _log_creation
# Dynamically add a property that provides info about the metaclass's influence
def get_meta_info(self):
return f"This is an object of {name}, dynamically enhanced by MetaPropertyCreator."
dct['meta_info'] = property(get_meta_info)
# Create the class using the modified dictionary
return super().__new__(mcs, name, bases, dct)
class DynamicClass(metaclass=MetaPropertyCreator):
def __init__(self, value):
self.value = value
def do_something(self):
print(f"Doing something with value: {self.value}")
class AnotherDynamicClass(metaclass=MetaPropertyCreator):
def __init__(self, data):
self.data = data
# Calling the method injected by the metaclass
self._log_creation()
# --- Usage Examples ---
print("--- DynamicClass Example ---")
obj1 = DynamicClass("Hello Metaclass!")
obj1._log_creation() # Call the dynamically added method
obj1.do_something()
print(obj1.meta_info) # Access the dynamically added property
print("n--- AnotherDynamicClass Example ---")
obj2 = AnotherDynamicClass({"id": 123, "status": "active"})
print(obj2.meta_info) # Access the dynamically added property
```
Output example:
```
--- DynamicClass Example ---
[DynamicClass] Instance created: {'value': 'Hello Metaclass!'}
Doing something with value: Hello Metaclass!
This is an object of DynamicClass, dynamically enhanced by MetaPropertyCreator.
--- AnotherDynamicClass Example ---
[AnotherDynamicClass] Instance created: {'data': {'id': 123, 'status': 'active'}}
This is an object of AnotherDynamicClass, dynamically enhanced by MetaPropertyCreator.
```
**Small Challenge:**
Modify the `MetaPropertyCreator` metaclass to automatically add a `__str__` method to classes using it. This `__str__` method should return a string representation of the instance, including all its attributes in a readable format (e.g., `ClassName(attr1=value1, attr2=value2)`).
---
Ever wondered how powerful Python frameworks dynamically generate code or alter class behavior *before* a single instance is even created? Today, we dive deep into Metaclasses! This isn't just about simple class factories; it's about programmatically defining the very blueprints of your classes, injecting methods, properties, or even entire architectural patterns at definition time. Get ready to bend Python to your will and explore true programmatic reflection! 💡
```python
class MetaPropertyCreator(type):
"""
A metaclass that dynamically adds a '_log_creation' method and a
'meta_info' property to any class it creates.
"""
def __new__(mcs, name, bases, dct):
# Dynamically add a method to log instance creation
def _log_creation(self):
print(f"[{name}] Instance created: {self.__dict__}")
dct['_log_creation'] = _log_creation
# Dynamically add a property that provides info about the metaclass's influence
def get_meta_info(self):
return f"This is an object of {name}, dynamically enhanced by MetaPropertyCreator."
dct['meta_info'] = property(get_meta_info)
# Create the class using the modified dictionary
return super().__new__(mcs, name, bases, dct)
class DynamicClass(metaclass=MetaPropertyCreator):
def __init__(self, value):
self.value = value
def do_something(self):
print(f"Doing something with value: {self.value}")
class AnotherDynamicClass(metaclass=MetaPropertyCreator):
def __init__(self, data):
self.data = data
# Calling the method injected by the metaclass
self._log_creation()
# --- Usage Examples ---
print("--- DynamicClass Example ---")
obj1 = DynamicClass("Hello Metaclass!")
obj1._log_creation() # Call the dynamically added method
obj1.do_something()
print(obj1.meta_info) # Access the dynamically added property
print("n--- AnotherDynamicClass Example ---")
obj2 = AnotherDynamicClass({"id": 123, "status": "active"})
print(obj2.meta_info) # Access the dynamically added property
```
Output example:
```
--- DynamicClass Example ---
[DynamicClass] Instance created: {'value': 'Hello Metaclass!'}
Doing something with value: Hello Metaclass!
This is an object of DynamicClass, dynamically enhanced by MetaPropertyCreator.
--- AnotherDynamicClass Example ---
[AnotherDynamicClass] Instance created: {'data': {'id': 123, 'status': 'active'}}
This is an object of AnotherDynamicClass, dynamically enhanced by MetaPropertyCreator.
```
**Small Challenge:**
Modify the `MetaPropertyCreator` metaclass to automatically add a `__str__` method to classes using it. This `__str__` method should return a string representation of the instance, including all its attributes in a readable format (e.g., `ClassName(attr1=value1, attr2=value2)`).
---
❤1
Which method of a descriptor is responsible for retrieving the attribute's value when accessed from an instance?
Anonymous Quiz
0%
A) `__set__`
50%
B) `__delete__`
25%
C) `__get__`
25%
D) `__init__`
What is the primary role of a metaclass when combined with descriptors, as demonstrated in the example?
Anonymous Quiz
67%
A) To define instance-specific attribute values.
0%
B) To automatically transform simple class attributes into descriptor-managed attributes.
33%
C) To prevent any form of attribute access after class creation.
0%
D) To strictly enforce that all attributes must be callable methods.
Which of the following attributes of a Python function object provides direct access to its compiled bytecode and essential metadata required for execution?
Anonymous Quiz
0%
`__code__`
33%
`__globals__`
67%
`__annotations__`
0%
`__defaults__`
Hey everyone! 👋 We will start from day 1 🗓️. Please share this channel with your friends who want to learn Python from scratch 🐍💻.
Here's your Telegram post and quiz question!
---
🎉 Welcome to Day 1 of our Python Learning Series! 🐍
Today, we're kicking off with the absolute classic: "Hello, World!" This simple program is your first step into coding and helps confirm your Python environment is ready. You'll learn how to use the `print()` function to display text on your screen. Get ready to type your very first line of Python code! 🚀
---
```python
print("Hello, World!")
```
---
Output example:
```
Hello, World!
```
---
✨ Your Challenge:
Modify the code above to print your name instead of "World!" For example, if your name is Alice, it would print "Hello, Alice!". Give it a try! 👇
---
---
🎉 Welcome to Day 1 of our Python Learning Series! 🐍
Today, we're kicking off with the absolute classic: "Hello, World!" This simple program is your first step into coding and helps confirm your Python environment is ready. You'll learn how to use the `print()` function to display text on your screen. Get ready to type your very first line of Python code! 🚀
---
```python
print("Hello, World!")
```
---
Output example:
```
Hello, World!
```
---
✨ Your Challenge:
Modify the code above to print your name instead of "World!" For example, if your name is Alice, it would print "Hello, Alice!". Give it a try! 👇
---
Which Python function is used to display output (text or data) to the console?
Anonymous Quiz
0%
show()
33%
print()
67%
display()
0%
output()
Here's your Telegram post for Day 2 of the Python learning series, including the quiz question in JSON format:
---
🐍 **Python Learning Series - Day 2: Variables and Data Types** 🚀
Welcome back, Pythonistas! Today, we're unlocking the secret to storing and managing information in your programs: **Variables and Data Types**! 🧠
Think of variables as named containers that hold different kinds of data. Whether it's numbers, text, or even true/false values, variables are essential for making your code dynamic and interactive. Understanding what type of data your variable holds helps Python know how to work with it. Let's dive in and see them in action! ✨
```python
# Day 2: Variables and Data Types
# Variables are like labeled containers for your data!
# 1. Integer (whole numbers without decimals)
my_age = 30
print(f"My age: {my_age}, Type: {type(my_age)}")
# 2. Float (numbers with decimals)
my_height = 1.75
print(f"My height: {my_height}, Type: {type(my_height)}")
# 3. String (text, enclosed in single or double quotes)
my_name = "Alice"
print(f"My name: {my_name}, Type: {type(my_name)}")
# 4. Boolean (True or False values, case-sensitive)
is_learning_python = True
print(f"Am I learning Python? {is_learning_python}, Type: {type(is_learning_python)}")
# You can easily change a variable's value!
my_age = my_age + 1 # Incrementing the age by 1
print(f"Next year, my age will be: {my_age}")
message = "Python is super cool! 😎 Keep practicing!"
print(message)
```
Output example:
```
My age: 30, Type: <class 'int'>
My height: 1.75, Type: <class 'float'>
My name: Alice, Type: <class 'str'>
Am I learning Python? True, Type: <class 'bool'>
Next year, my age will be: 31
Python is super cool! 😎 Keep practicing!
```
💡 **Your Challenge:**
1. Create a variable named `favorite_city` and assign your favorite city (as a string) to it.
2. Create another variable `current_temp` and store the current temperature (as a float, e.g., 25.5) in it.
3. Print both variables along with their data types, just like we did in the examples!
Share your solutions or questions in the comments below! 👇 Let's keep building our Python skills! ✅
---
---
🐍 **Python Learning Series - Day 2: Variables and Data Types** 🚀
Welcome back, Pythonistas! Today, we're unlocking the secret to storing and managing information in your programs: **Variables and Data Types**! 🧠
Think of variables as named containers that hold different kinds of data. Whether it's numbers, text, or even true/false values, variables are essential for making your code dynamic and interactive. Understanding what type of data your variable holds helps Python know how to work with it. Let's dive in and see them in action! ✨
```python
# Day 2: Variables and Data Types
# Variables are like labeled containers for your data!
# 1. Integer (whole numbers without decimals)
my_age = 30
print(f"My age: {my_age}, Type: {type(my_age)}")
# 2. Float (numbers with decimals)
my_height = 1.75
print(f"My height: {my_height}, Type: {type(my_height)}")
# 3. String (text, enclosed in single or double quotes)
my_name = "Alice"
print(f"My name: {my_name}, Type: {type(my_name)}")
# 4. Boolean (True or False values, case-sensitive)
is_learning_python = True
print(f"Am I learning Python? {is_learning_python}, Type: {type(is_learning_python)}")
# You can easily change a variable's value!
my_age = my_age + 1 # Incrementing the age by 1
print(f"Next year, my age will be: {my_age}")
message = "Python is super cool! 😎 Keep practicing!"
print(message)
```
Output example:
```
My age: 30, Type: <class 'int'>
My height: 1.75, Type: <class 'float'>
My name: Alice, Type: <class 'str'>
Am I learning Python? True, Type: <class 'bool'>
Next year, my age will be: 31
Python is super cool! 😎 Keep practicing!
```
💡 **Your Challenge:**
1. Create a variable named `favorite_city` and assign your favorite city (as a string) to it.
2. Create another variable `current_temp` and store the current temperature (as a float, e.g., 25.5) in it.
3. Print both variables along with their data types, just like we did in the examples!
Share your solutions or questions in the comments below! 👇 Let's keep building our Python skills! ✅
---
What is the correct way to assign the integer value `100` to a variable named `score` in Python?
Anonymous Quiz
0%
score = 100
0%
score == 100
0%
100 = score
0%
int score = 100
🚀 Day 3 of our Python journey is here! Today, we're diving into the core of computation: **Operators**! 💡
Operators are special symbols that perform operations on variables and values. From basic math to complex logic, they are your essential tools to manipulate data and make your programs do amazing things. Understanding them is key to writing effective Python code. Let's explore some common types! 👇
```python
# Day 3: Operators in Python
# Arithmetic Operators (+, -, *, /, //, %, **)
a = 15
b = 4
print(f"Addition (a + b): {a + b}")
print(f"Subtraction (a - b): {a - b}")
print(f"Multiplication (a * b): {a * b}")
print(f"Division (a / b): {a / b}") # Returns a float
print(f"Floor Division (a // b): {a // b}") # Returns an integer (discards fraction)
print(f"Modulus (a % b): {a % b}") # Returns the remainder
print(f"Exponentiation (a ** 2): {a ** 2}") # a to the power of 2
print("-" * 20)
# Comparison Operators (==, !=, <, >, <=, >=)
x = 10
y = 7
print(f"Equal to (x == y): {x == y}")
print(f"Not equal to (x != y): {x != y}")
print(f"Greater than (x > y): {x > y}")
print(f"Less than (x < y): {x < y}")
print(f"Greater or equal (x >= 10): {x >= 10}")
print("-" * 20)
# Logical Operators (and, or, not)
is_sunny = True
is_warm = False
print(f"AND (is_sunny and is_warm): {is_sunny and is_warm}") # Both must be True
print(f"OR (is_sunny or is_warm): {is_sunny or is_warm}") # At least one must be True
print(f"NOT (not is_warm): {not is_warm}") # Reverses the boolean value
print("-" * 20)
# Assignment Operator (= and shorthand like +=, -=)
score = 100
score += 50 # Equivalent to: score = score + 50
print(f"Score after += 50: {score}")
total_items = 10
total_items -= 2 # Equivalent to: total_items = total_items - 2
print(f"Total items after -= 2: {total_items}")
```
Output example:
```
Addition (a + b): 19
Subtraction (a - b): 11
Multiplication (a * b): 60
Division (a / b): 3.75
Floor Division (a // b): 3
Modulus (a % b): 3
Exponentiation (a ** 2): 225
--------------------
Equal to (x == y): False
Not equal to (x != y): True
Greater than (x > y): True
Less than (x < y): False
Greater or equal (x >= 10): True
--------------------
AND (is_sunny and is_warm): False
OR (is_sunny or is_warm): True
NOT (not is_warm): True
--------------------
Score after += 50: 150
Total items after -= 2: 8
```
🤔 **Your Challenge!**
What would be the output of these two expressions?
1. `(20 - 5 * 2) // 3`
2. `True and not (5 > 10)`
Try to predict before running it in a Python interpreter! Share your answers below! 👇
***
Operators are special symbols that perform operations on variables and values. From basic math to complex logic, they are your essential tools to manipulate data and make your programs do amazing things. Understanding them is key to writing effective Python code. Let's explore some common types! 👇
```python
# Day 3: Operators in Python
# Arithmetic Operators (+, -, *, /, //, %, **)
a = 15
b = 4
print(f"Addition (a + b): {a + b}")
print(f"Subtraction (a - b): {a - b}")
print(f"Multiplication (a * b): {a * b}")
print(f"Division (a / b): {a / b}") # Returns a float
print(f"Floor Division (a // b): {a // b}") # Returns an integer (discards fraction)
print(f"Modulus (a % b): {a % b}") # Returns the remainder
print(f"Exponentiation (a ** 2): {a ** 2}") # a to the power of 2
print("-" * 20)
# Comparison Operators (==, !=, <, >, <=, >=)
x = 10
y = 7
print(f"Equal to (x == y): {x == y}")
print(f"Not equal to (x != y): {x != y}")
print(f"Greater than (x > y): {x > y}")
print(f"Less than (x < y): {x < y}")
print(f"Greater or equal (x >= 10): {x >= 10}")
print("-" * 20)
# Logical Operators (and, or, not)
is_sunny = True
is_warm = False
print(f"AND (is_sunny and is_warm): {is_sunny and is_warm}") # Both must be True
print(f"OR (is_sunny or is_warm): {is_sunny or is_warm}") # At least one must be True
print(f"NOT (not is_warm): {not is_warm}") # Reverses the boolean value
print("-" * 20)
# Assignment Operator (= and shorthand like +=, -=)
score = 100
score += 50 # Equivalent to: score = score + 50
print(f"Score after += 50: {score}")
total_items = 10
total_items -= 2 # Equivalent to: total_items = total_items - 2
print(f"Total items after -= 2: {total_items}")
```
Output example:
```
Addition (a + b): 19
Subtraction (a - b): 11
Multiplication (a * b): 60
Division (a / b): 3.75
Floor Division (a // b): 3
Modulus (a % b): 3
Exponentiation (a ** 2): 225
--------------------
Equal to (x == y): False
Not equal to (x != y): True
Greater than (x > y): True
Less than (x < y): False
Greater or equal (x >= 10): True
--------------------
AND (is_sunny and is_warm): False
OR (is_sunny or is_warm): True
NOT (not is_warm): True
--------------------
Score after += 50: 150
Total items after -= 2: 8
```
🤔 **Your Challenge!**
What would be the output of these two expressions?
1. `(20 - 5 * 2) // 3`
2. `True and not (5 > 10)`
Try to predict before running it in a Python interpreter! Share your answers below! 👇
***
Which of the following operators in Python is used to check if two values are *not* equal?
Anonymous Quiz
0%
==
0%
=
0%
!=
0%
>=
🚀 Welcome back to Python Day 4! Today, we're diving into the heart of decision-making in code: **Conditional Statements**! 🚦 Ever wondered how programs choose different paths based on conditions? 🤔 That's where `if`, `elif` (short for "else if"), and `else` come in!
They allow your code to execute specific blocks only when certain criteria are met. This is fundamental for creating dynamic and responsive programs. Get ready to make your Python scripts smarter and more interactive! Let's explore how to control the flow! 👇
```python
# Day 4: Conditional Statements (if, elif, else)
# Let's check a student's grade based on their score
score = 85
if score >= 90:
print("Excellent! You got an A. 🎉")
elif score >= 80:
print("Great job! You got a B. 👍")
elif score >= 70:
print("Good effort! You got a C. 😊")
elif score >= 60:
print("You passed! You got a D. 😉")
else:
print("Keep practicing! You need to improve. 💪")
print("n--- Grade check complete ---")
```
Output example:
```
Great job! You got a B. 👍
--- Grade check complete ---
```
**Small Challenge:**
What would the output be if `score` was `95`? How about `55`? Try changing the `score` variable in the code and observe the different outcomes! Can you add another `elif` condition for a specific score, like `score == 100`? 🤔
---
They allow your code to execute specific blocks only when certain criteria are met. This is fundamental for creating dynamic and responsive programs. Get ready to make your Python scripts smarter and more interactive! Let's explore how to control the flow! 👇
```python
# Day 4: Conditional Statements (if, elif, else)
# Let's check a student's grade based on their score
score = 85
if score >= 90:
print("Excellent! You got an A. 🎉")
elif score >= 80:
print("Great job! You got a B. 👍")
elif score >= 70:
print("Good effort! You got a C. 😊")
elif score >= 60:
print("You passed! You got a D. 😉")
else:
print("Keep practicing! You need to improve. 💪")
print("n--- Grade check complete ---")
```
Output example:
```
Great job! You got a B. 👍
--- Grade check complete ---
```
**Small Challenge:**
What would the output be if `score` was `95`? How about `55`? Try changing the `score` variable in the code and observe the different outcomes! Can you add another `elif` condition for a specific score, like `score == 100`? 🤔
---