Writing Simple Programs with Conditions
Table of Contents
1. [Introduction to Conditional Programming](#introduction-to-conditional-programming) 2. [Basic Conditional Statements](#basic-conditional-statements) 3. [Comparison Operators](#comparison-operators) 4. [Logical Operators](#logical-operators) 5. [Nested Conditions](#nested-conditions) 6. [Switch Statements](#switch-statements) 7. [Practical Examples](#practical-examples) 8. [Best Practices](#best-practices) 9. [Common Mistakes](#common-mistakes) 10. [Advanced Conditional Concepts](#advanced-conditional-concepts)Introduction to Conditional Programming
Conditional programming forms the backbone of decision-making in software development. It allows programs to execute different code paths based on specific conditions, making applications dynamic and responsive to user input and changing data states. Without conditional statements, programs would be linear and unable to adapt to different scenarios.
Conditional statements evaluate expressions that return boolean values (true or false) and execute corresponding code blocks. This fundamental concept enables programs to implement business logic, validate user input, control program flow, and create interactive applications.
Basic Conditional Statements
If Statement
The if statement is the most fundamental conditional construct in programming. It executes a block of code only when a specified condition evaluates to true.
Syntax Structure:
`
if (condition) {
// Code to execute when condition is true
}
`
Python Example:
`python
age = 18
if age >= 18:
print("You are eligible to vote")
`
JavaScript Example:
`javascript
let temperature = 25;
if (temperature > 20) {
console.log("It's a warm day");
}
`
Java Example:
`java
int score = 85;
if (score >= 80) {
System.out.println("Excellent performance");
}
`
If-Else Statement
The if-else statement provides an alternative execution path when the primary condition is false, ensuring that one of two code blocks will always execute.
Syntax Structure:
`
if (condition) {
// Code when condition is true
} else {
// Code when condition is false
}
`
Python Example:
`python
password = input("Enter password: ")
if len(password) >= 8:
print("Password is strong enough")
else:
print("Password is too short")
`
If-Elif-Else Statement (Multiple Conditions)
This structure allows checking multiple conditions in sequence, providing more granular control over program flow.
Python Example:
`python
grade = 87
if grade >= 90:
letter_grade = "A"
elif grade >= 80:
letter_grade = "B"
elif grade >= 70:
letter_grade = "C"
elif grade >= 60:
letter_grade = "D"
else:
letter_grade = "F"
print(f"Your grade is: {letter_grade}")
`
Comparison Operators
Comparison operators are essential tools for creating conditions in programming. They compare values and return boolean results.
| Operator | Description | Example | Result |
|----------|-------------|---------|--------|
| == | Equal to | 5 == 5 | True |
| != | Not equal to | 5 != 3 | True |
| > | Greater than | 7 > 3 | True |
| < | Less than | 2 < 8 | True |
| >= | Greater than or equal | 5 >= 5 | True |
| <= | Less than or equal | 4 <= 6 | True |
String Comparison Examples
`python
String equality
username = "admin" if username == "admin": print("Administrator access granted")String inequality
user_input = "guest" if user_input != "admin": print("Limited access granted")Alphabetical comparison
name1 = "Alice" name2 = "Bob" if name1 < name2: # Alphabetically earlier print(f"{name1} comes before {name2}")Numeric Comparison Examples
`python
Integer comparisons
x = 10 y = 20 if x < y: print(f"{x} is less than {y}")Float comparisons
price = 19.99 budget = 20.00 if price <= budget: print("Item is within budget")Range checking
temperature = 25 if 20 <= temperature <= 30: print("Temperature is in comfortable range")Logical Operators
Logical operators combine multiple conditions to create more complex conditional expressions.
| Operator | Description | Example | Result |
|----------|-------------|---------|--------|
| and (&&) | Both conditions true | True and False | False |
| or (\|\|) | At least one condition true | True or False | True |
| not (!) | Negates the condition | not True | False |
Truth Tables
AND Operator Truth Table: | A | B | A and B | |---|---|---------| | True | True | True | | True | False | False | | False | True | False | | False | False | False |
OR Operator Truth Table: | A | B | A or B | |---|---|--------| | True | True | True | | True | False | True | | False | True | True | | False | False | False |
NOT Operator Truth Table: | A | not A | |---|-------| | True | False | | False | True |
Practical Logical Operator Examples
`python
User authentication system
username = "john_doe" password = "secure123" is_active = Trueif username == "john_doe" and password == "secure123" and is_active: print("Login successful") else: print("Login failed")
Age and license validation
age = 17 has_license = Falseif age >= 18 or has_license: print("Can drive") else: print("Cannot drive")
Inventory management
stock_level = 5 is_discontinued = Falseif not is_discontinued and stock_level > 0:
print("Item available for purchase")
else:
print("Item not available")
`
Nested Conditions
Nested conditions involve placing conditional statements inside other conditional statements, creating hierarchical decision trees.
Simple Nested Example
`python
weather = "sunny"
temperature = 25
if weather == "sunny":
if temperature > 20:
print("Perfect day for outdoor activities")
else:
print("Sunny but cold")
else:
if temperature > 20:
print("Warm but not sunny")
else:
print("Cold and not sunny")
`
Complex Nested Example - Student Grading System
`python
def evaluate_student(attendance, assignments_completed, exam_score):
if attendance >= 80:
if assignments_completed >= 8:
if exam_score >= 70:
return "Pass with distinction"
elif exam_score >= 50:
return "Pass"
else:
return "Fail - Low exam score"
else:
return "Fail - Insufficient assignments"
else:
return "Fail - Poor attendance"
Test the function
result = evaluate_student(85, 9, 75) print(result) # Output: Pass with distinctionSwitch Statements
Switch statements provide an elegant way to handle multiple discrete conditions, especially when comparing a single variable against multiple values.
JavaScript Switch Example
`javascript
function getDayType(dayNumber) {
let dayType;
switch (dayNumber) {
case 1:
case 2:
case 3:
case 4:
case 5:
dayType = "Weekday";
break;
case 6:
case 7:
dayType = "Weekend";
break;
default:
dayType = "Invalid day";
}
return dayType;
}
console.log(getDayType(3)); // Output: Weekday
console.log(getDayType(7)); // Output: Weekend
`
Python Switch-like Implementation (Python 3.10+)
`python
def process_grade(letter):
match letter:
case 'A':
return "Excellent - 90-100%"
case 'B':
return "Good - 80-89%"
case 'C':
return "Average - 70-79%"
case 'D':
return "Below Average - 60-69%"
case 'F':
return "Fail - Below 60%"
case _:
return "Invalid grade"
print(process_grade('A')) # Output: Excellent - 90-100%
`
Traditional Python Dictionary-based Switch
`python
def get_month_days(month):
month_days = {
1: 31, 2: 28, 3: 31, 4: 30,
5: 31, 6: 30, 7: 31, 8: 31,
9: 30, 10: 31, 11: 30, 12: 31
}
return month_days.get(month, "Invalid month")
print(get_month_days(2)) # Output: 28
`
Practical Examples
Example 1: Banking System
`python
class SimpleBankAccount:
def __init__(self, initial_balance=0):
self.balance = initial_balance
self.transaction_history = []
def withdraw(self, amount):
if amount <= 0:
return "Invalid amount. Must be positive."
elif amount > self.balance:
return "Insufficient funds."
elif amount > 1000:
return "Daily withdrawal limit exceeded."
else:
self.balance -= amount
self.transaction_history.append(f"Withdrawal: ${amount}")
return f"Withdrawal successful. New balance: ${self.balance}"
def deposit(self, amount):
if amount <= 0:
return "Invalid amount. Must be positive."
elif amount > 10000:
return "Large deposit requires manager approval."
else:
self.balance += amount
self.transaction_history.append(f"Deposit: ${amount}")
return f"Deposit successful. New balance: ${self.balance}"
Usage example
account = SimpleBankAccount(500) print(account.withdraw(200)) # Withdrawal successful. New balance: $300 print(account.withdraw(400)) # Insufficient funds. print(account.deposit(1000)) # Deposit successful. New balance: $1300Example 2: Grade Calculator
`python
def calculate_final_grade(assignments, midterm, final_exam, participation):
# Validate input ranges
if not all(0 <= score <= 100 for score in [assignments, midterm, final_exam, participation]):
return "Error: All scores must be between 0 and 100"
# Calculate weighted average
final_grade = (assignments 0.3 + midterm 0.25 +
final_exam 0.35 + participation 0.1)
# Determine letter grade and status
if final_grade >= 97:
letter = "A+"
status = "Outstanding"
elif final_grade >= 93:
letter = "A"
status = "Excellent"
elif final_grade >= 90:
letter = "A-"
status = "Very Good"
elif final_grade >= 87:
letter = "B+"
status = "Good"
elif final_grade >= 83:
letter = "B"
status = "Above Average"
elif final_grade >= 80:
letter = "B-"
status = "Satisfactory"
elif final_grade >= 77:
letter = "C+"
status = "Below Average"
elif final_grade >= 73:
letter = "C"
status = "Poor"
elif final_grade >= 70:
letter = "C-"
status = "Very Poor"
elif final_grade >= 60:
letter = "D"
status = "Failing"
else:
letter = "F"
status = "Failing"
return {
"numeric_grade": round(final_grade, 2),
"letter_grade": letter,
"status": status,
"passed": final_grade >= 70
}
Test the function
result = calculate_final_grade(85, 78, 92, 88) print(f"Grade: {result['numeric_grade']} ({result['letter_grade']})") print(f"Status: {result['status']}") print(f"Passed: {result['passed']}")Example 3: Weather Advisory System
`python
def weather_advisory(temperature, humidity, wind_speed, precipitation):
advisories = []
# Temperature advisories
if temperature > 35:
advisories.append("HEAT WARNING: Extremely hot weather. Stay hydrated.")
elif temperature > 30:
advisories.append("Heat advisory: Hot weather expected.")
elif temperature < -10:
advisories.append("FREEZE WARNING: Extremely cold weather.")
elif temperature < 0:
advisories.append("Cold weather advisory.")
# Humidity advisories
if humidity > 80:
advisories.append("High humidity: Feels hotter than actual temperature.")
elif humidity < 20:
advisories.append("Low humidity: Dry conditions.")
# Wind advisories
if wind_speed > 50:
advisories.append("WIND WARNING: Dangerous wind speeds.")
elif wind_speed > 30:
advisories.append("Wind advisory: Strong winds expected.")
# Precipitation advisories
if precipitation > 50:
advisories.append("FLOOD WARNING: Heavy precipitation expected.")
elif precipitation > 20:
advisories.append("Rain advisory: Significant precipitation.")
# Combined condition advisories
if temperature > 30 and humidity > 70:
advisories.append("Heat index warning: Dangerous heat and humidity combination.")
if temperature < 0 and wind_speed > 20:
advisories.append("Wind chill warning: Dangerous cold and wind combination.")
return advisories if advisories else ["No weather advisories at this time."]
Test the system
advisories = weather_advisory(32, 75, 15, 5) for advisory in advisories: print(f"• {advisory}")Best Practices
Code Organization and Readability
| Practice | Good Example | Poor Example |
|----------|--------------|--------------|
| Use meaningful variable names | if user_age >= minimum_voting_age: | if x >= y: |
| Keep conditions simple | if is_valid_user(): | if check_user() == True and verify() != False: |
| Use early returns | if not valid: return False | Deep nesting |
| Group related conditions | Use logical operators | Multiple separate ifs |
Performance Considerations
`python
Good: Short-circuit evaluation
def expensive_operation(): # Simulate expensive computation import time time.sleep(1) return Truedef check_conditions(quick_check, expensive_check_needed): # Quick check first - if false, expensive operation never runs if quick_check and expensive_check_needed and expensive_operation(): return "All conditions met" return "Conditions not met"
Good: Avoid repeated calculations
user_input = get_user_input() input_length = len(user_input) # Calculate once if input_length > 0 and input_length < 100: process_input(user_input)Poor: Repeated calculation
if len(user_input) > 0 and len(user_input) < 100:
Error Handling Integration
`python
def safe_divide(dividend, divisor):
# Input validation with conditions
if not isinstance(dividend, (int, float)) or not isinstance(divisor, (int, float)):
return "Error: Both arguments must be numbers"
if divisor == 0:
return "Error: Cannot divide by zero"
result = dividend / divisor
# Result validation
if abs(result) > 1e10:
return "Warning: Result is very large"
elif abs(result) < 1e-10 and result != 0:
return "Warning: Result is very small"
else:
return result
Test cases
print(safe_divide(10, 2)) # 5.0 print(safe_divide(10, 0)) # Error: Cannot divide by zero print(safe_divide("10", 2)) # Error: Both arguments must be numbersCommon Mistakes
Mistake 1: Assignment vs Comparison
`python
WRONG: Using assignment (=) instead of comparison (==)
x = 5 if x = 10: # SyntaxError in Python, logic error in other languages print("x is 10")CORRECT:
if x == 10: print("x is 10")Mistake 2: Floating Point Comparison
`python
WRONG: Direct floating point comparison
a = 0.1 + 0.2 if a == 0.3: print("Equal") # This might not print due to floating point precisionCORRECT: Use tolerance for floating point comparison
import math if math.isclose(a, 0.3): print("Equal")Alternative approach
tolerance = 1e-10 if abs(a - 0.3) < tolerance: print("Equal")Mistake 3: Boolean Redundancy
`python
WRONG: Redundant boolean comparison
is_valid = True if is_valid == True: print("Valid")CORRECT: Direct boolean evaluation
if is_valid: print("Valid")WRONG: Redundant boolean return
def is_even(number): if number % 2 == 0: return True else: return FalseCORRECT: Direct return
def is_even(number): return number % 2 == 0Mistake 4: Logical Operator Confusion
`python
WRONG: Incorrect range checking
age = 25 if age > 18 and < 65: # SyntaxError print("Working age")CORRECT: Proper range checking
if 18 < age < 65: # Pythonic way print("Working age")Alternative correct way
if age > 18 and age < 65: print("Working age")Advanced Conditional Concepts
Ternary Operators (Conditional Expressions)
Ternary operators provide a concise way to write simple if-else statements in a single line.
`python
Python ternary operator
age = 20 status = "adult" if age >= 18 else "minor" print(status) # Output: adultMultiple ternary operators (use sparingly)
grade = 85 letter = "A" if grade >= 90 else "B" if grade >= 80 else "C" if grade >= 70 else "F"JavaScript ternary operator
let status = age >= 18 ? "adult" : "minor";
Java ternary operator
String status = age >= 18 ? "adult" : "minor";
Short-Circuit Evaluation
Understanding how logical operators evaluate expressions can optimize performance and prevent errors.
`python
def risky_operation():
# Simulate an operation that might fail
raise Exception("Something went wrong")
Safe usage with short-circuit evaluation
safe_mode = True result = safe_mode or risky_operation() # risky_operation() never calledUnsafe usage
result = risky_operation() or safe_mode # Exception would be raised
Practical example: Safe attribute access
class User: def __init__(self, name=None): self.name = nameuser = User()
Safe way to check nested attributes
if hasattr(user, 'name') and user.name and len(user.name) > 0: print(f"User name: {user.name}") else: print("User name not available")Conditional Comprehensions
Advanced conditional usage in list comprehensions and generator expressions.
`python
List comprehension with conditions
numbers = range(1, 21) even_squares = [x2 for x in numbers if x % 2 == 0] print(even_squares) # [4, 16, 36, 64, 100, 144, 196, 256, 324, 400]Conditional expression in comprehension
processed_numbers = [x if x > 0 else 0 for x in [-2, -1, 0, 1, 2]] print(processed_numbers) # [0, 0, 0, 1, 2]Dictionary comprehension with conditions
students = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'Diana': 96} honor_students = {name: grade for name, grade in students.items() if grade >= 90} print(honor_students) # {'Bob': 92, 'Diana': 96}Generator expression with complex conditions
large_even_squares = (x2 for x in range(1, 1000) if x % 2 == 0 and x2 > 100) print(list(large_even_squares)[:5]) # First 5 valuesPattern Matching (Python 3.10+)
Modern Python includes sophisticated pattern matching capabilities that extend beyond simple switch statements.
`python
def analyze_data(data):
match data:
case int() if data > 100:
return f"Large integer: {data}"
case int() if data > 0:
return f"Positive integer: {data}"
case int():
return f"Non-positive integer: {data}"
case str() if len(data) > 10:
return f"Long string: {data[:10]}..."
case str():
return f"Short string: {data}"
case list() if len(data) == 0:
return "Empty list"
case list() if all(isinstance(x, int) for x in data):
return f"Integer list with {len(data)} elements"
case dict():
return f"Dictionary with keys: {list(data.keys())}"
case _:
return f"Unknown data type: {type(data)}"
Test pattern matching
print(analyze_data(150)) # Large integer: 150 print(analyze_data("Hello")) # Short string: Hello print(analyze_data([1, 2, 3])) # Integer list with 3 elements print(analyze_data({"a": 1})) # Dictionary with keys: ['a']This comprehensive guide covers the fundamental concepts of conditional programming, from basic if statements to advanced pattern matching. Understanding these concepts and practicing their implementation will enable you to write more sophisticated and maintainable programs that can handle complex decision-making scenarios effectively.