Python Cheat Sheet
Uploaded by
Bharat KonduruPython Cheat Sheet
Uploaded by
Bharat Konduru his is a fantastic suggestion!
Integrating dunder methods, more design patterns, and
T
clarifying architectural patterns like MVC will make this cheat sheet truly comprehensive for
anyone learning Python.
Let's expand the "Advanced Concepts" section and add a new section for "Design Patterns."
Python Cheat Sheet (Basic to Advanced with Examples)
his comprehensive cheat sheet provides a quick reference for fundamental to advanced
T
Python concepts, syntax, and common functions, accompanied by concrete examples for
every entry.
1. Basic Syntax and Data Types
● C
omments:
○ Single-line:
Python
# This is a single-line comment
print("Hello")# This comment explains the line
○ M
ulti-line:
Python
" ""
This is a multi-line comment.
It can span several lines
and is often used for docstrings.
"""
defgreet(name):
"""
This function greets the person passed in as a parameter.
"""
print(f"Hello,{name}!")
greet("Alice")
● V
ariables:
○ No explicit type declaration. Type is inferred.
○ Python
my_integer_variable =10
my_string_variable ="Python is fun!"
print(my_integer_variable) # Output: 10
print(my_string_variable) # Output: Python is fun!
● Data Types:
○ I ntegers:Whole numbers.
Python
age =30
print(f"Age:{age}, Type:{t ype(age)}")# Output: Age: 30, Type: <class 'int'>
○ F
loats:Numbers with decimal points.
Python
price =19.99
pi =3.14159
print(f"Price:{price}, Type:{type(price)}")# Output: Price: 19.99, Type: <class 'float'>
○ S
trings:Sequences of characters.
Python
message ="Hello, Python!"
greeting ='Welcome!'
print(f"Message:{message}, Type:{type(message)}")# Output: Message: Hello, Python!,
Type: <class 'str'>
○ B
ooleans:Represent True or False.
Python
is_active =True
has_permission =False
print(f"Is active:{is_active}, Type:{t ype(is_active)}")# Output: Is active: True, Type: <class
'bool'>
○ N
oneType:Represents the absence of a value.
Python
result =None
print(f"Result:{result}, Type:{t ype(result)}") # Output: Result: None, Type: <class
'NoneType'>
2. Operators
● A
rithmetic Operators:
○ + (addition), - (subtraction), * (multiplication), / (division)
Python
a, b =10,3
print(f"10 + 3 ={a + b}")# Output: 10 + 3 = 13
print(f"10 - 3 ={a - b}")# Output: 10 - 3 = 7
print(f"10 * 3 ={a * b}")# Output: 10 * 3 = 30
print(f"10 / 3 ={a / b}")# Output: 10 / 3 = 3.333...
○ %
(modulo - remainder)
Python
print(f"10 % 3 ={1 0%3}" )# Output: 10 % 3 = 1 (10 divided by 3 is 3 with a remainder of 1)
○ * * (exponentiation)
Python
print(f"2 ** 3 ={2 **3} ") # Output: 2 ** 3 = 8 (2 to the power of 3)
○ / / (floor division - rounds down to the nearest integer)
Python
print(f"10 // 3 ={1 0//3} ") # Output: 10 // 3 = 3
print(f"-10 // 3 ={-10//3} ") # Output: -10 // 3 = -4
● C
omparison Operators:
○ == (equal to), != (not equal to)
Python
print(f"5 == 5:{5
==5} ") # Output: 5 == 5: True
print(f"5 != 10:{5!=10}" )# Output: 5 != 10: True
○ <
(less than), > (greater than)
Python
print(f"5 < 10:{5 <10}") # Output: 5 < 10: True
print(f"10 > 5:{1 0>5} ") # Output: 10 > 5: True
○ <
= (less than or equal to), >= (greater than or equal to)
Python
print(f"5 <= 5:{5
<=5}" ) # Output: 5 <= 5: True
print(f"10 >= 5:{1 0>=5} ") # Output: 10 >= 5: True
● L
ogical Operators:
○ and (logical AND)
Python
print(f"True and False:{T rueandFalse}") # Output: True and False: False
print(f"True and True:{TrueandTrue}" ) # Output: True and True: True
○ o
r (logical OR)
Python
print(f"True or False:{TrueorFalse}") # Output: True or False: True
print(f"False or False:{FalseorFalse}" )# Output: False or False: False
○ n
ot (logical NOT)
Python
print(f"not True:{n
otTrue}") # Output: not True: False
print(f"not False:{n
otFalse}" )# Output: not False: True
● A
ssignment Operators:
○ = (assign)
Python
x =10
print(f"x ={x}")# Output: x = 10
○ +
=, -=, *= etc. (compound assignment)
■ x += 1 is equivalent to x = x + 1
ython
P
count =5
count +=2# Equivalent to: count = count + 2
print(f"count after +=:{count}")# Output: count after +=: 7
v alue =20
value -=5# Equivalent to: value = value - 5
print(f"value after -=:{value}")# Output: value after -=: 15
● I dentity Operators:
○ is: Checks if two variables refer to thesame objectin memory.
Python
list1 = [1,2,3]
list2 = [1,2,3]
list3 = list1
print(f"list1 == list2:{list1 == list2}")# Output: True (content is same)
print(f"list1 is list2:{list1islist2}") # Output: False (different objects)
print(f"list1 is list3:{list1islist3}")# Output: True (same object reference)
● M
embership Operators:
○ in: Checks if a value is present in a sequence (string, list, tuple, set, dictionary keys).
Python
my_fruits = ["apple","banana","cherry"]
print(f"'banana' in my_fruits:{'banana'inmy_fruits}") # Output: True
print(f"'grape' in my_fruits:{'grape'inmy_fruits}") # Output: False
print(f"'Py' in 'Python':{'Py'in'Python'}" ) # Output: True
y_dict_keys = {"name":"Alice","age":30}
m
print(f"'name' in my_dict_keys:{'name'inmy_dict_keys}")# Output: True (checks keys)
○ n
ot in: Checks if a value isnotpresent in a sequence.
Python
numbers = [1,2,3]
print(f"5 not in numbers:{5
notinnumbers}")# Output: True
3. Data Structures
● L
ists (Mutable, Ordered, Indexed):
○ Creation:
Python
my_list = [1,2,3,"apple",True]
print(f"Created list:{my_list}")# Output: Created list: [1, 2, 3, 'apple', True]
○ A
ccess: my_list[0] (first element), my_list[-1] (last element)
Python
print(f"First element:{my_list[0]}") # Output: First element: 1
print(f"Last element:{my_list[-1] }")# Output: Last element: True
○ S
licing: my_list[1:3] (elements from index 1 up to but not including 3)
Python
print(f"Slice (1 to 3):{my_list[1:3 ] }") # Output: Slice (1 to 3): [2, 3]
print(f"Slice from beginning to 2:{my_list[:3]}")# Output: Slice from beginning to 2: [1, 2, 3]
print(f"Slice from index 2 to end:{my_list[2:]}") # Output: Slice from index 2 to end: [3,
'apple', True]
○ M
ethods: append(), extend(), insert(), remove(), pop(), sort(), reverse(), len()
Python
fruits = ["apple","banana"]
[Link]("cherry")
print(f"After append:{fruits}") # Output: After append: ['apple', 'banana', 'cherry']
ore_fruits = ["date","elderberry"]
m
[Link](more_fruits)
print(f"After extend:{fruits}")# Output: After extend: ['apple', 'banana', 'cherry', 'date',
'elderberry']
f [Link](1,"grape")
print(f"After insert:{fruits}")# Output: After insert: ['apple', 'grape', 'banana', 'cherry', 'date',
'elderberry']
f [Link]("banana")
print(f"After remove:{fruits}") # Output: After remove: ['apple', 'grape', 'cherry', 'date',
'elderberry']
popped_fruit = [Link]()# Removes and returns the last item
print(f"Popped item:{popped_fruit}, List now:{fruits}")# Output: Popped item: elderberry,
List now: ['apple', 'grape', 'cherry', 'date']
umbers = [3,1,4,1,5,9]
n
[Link]()
print(f"After sort:{numbers}")# Output: After sort: [1, 1, 3, 4, 5, 9]
[Link]()
n
print(f"After reverse:{numbers}")# Output: After reverse: [9, 5, 4, 3, 1, 1]
print(f"Length of fruits:{len(fruits)}") # Output: Length of fruits: 4
● T
uples (Immutable, Ordered, Indexed):
○ Creation:
Python
my_tuple = (1,2,"banana",False)
print(f"Created tuple:{my_tuple}")# Output: Created tuple: (1, 2, 'banana', False)
○ A
ccess/Slicing: Same as lists
Python
print(f"First element of tuple:{my_tuple[0] }")# Output: First element of tuple: 1
print(f"Tuple slice (1 to 3):{my_tuple[1:3]}") # Output: Tuple slice (1 to 3): (2, 'banana')
○ C
annot modify elements after creation.
Python
my_tuple[0] = 99 # This would raise a TypeError: 'tuple' object does not support item
#
assignment
# print(my_tuple)
● D
ictionaries (Mutable, Unordered, Key-Value Pairs):
○ Creation:
Python
my_dict = {"name":"Bob","age":25,"city":"London"}
print(f"Created dictionary:{my_dict}") # Output: Created dictionary: {'name': 'Bob', 'age': 25,
'city': 'London'}
○ A
ccess:
Python
print(f"Name from dict:{my_dict['name']}")# Output: Name from dict: Bob
○ A
dd/Modify:
Python
my_dict["country"] ="UK"
print(f"After adding 'country':{my_dict}") # Output: After adding 'country': {'name': 'Bob',
'age': 26, 'city': 'London', 'country': 'UK'}
my_dict["age"] =26
print(f"After modifying 'age':{my_dict}") # Output: After modifying 'age': {'name': 'Bob', 'age':
26, 'city': 'London', 'country': 'UK'}
○ M
ethods: keys(), values(), items(), get(), pop()
Python
print(f"Keys:{my_dict.keys()}") # Output: Keys: dict_keys(['name', 'age', 'city', 'country'])
print(f"Values:{my_dict.values()}") # Output: Values: dict_values(['Bob', 26, 'London', 'UK'])
print(f"Items:{my_dict.items()}") # Output: Items: dict_items([('name', 'Bob'), ('age', 26),
('city', 'London'), ('country', 'UK')])
# Using get() to safely access a key (returns None if key not found)
print(f"Get 'city':{my_dict.get('city')}") # Output: Get 'city': London
rint(f"Get 'zip' (default None):{my_dict.get('zip')}")# Output: Get 'zip' (default None): None
p
print(f"Get 'zip' (with default value):{my_dict.get('zip','N/A')}")# Output: Get 'zip' (with
default value): N/A
opped_value = my_dict.pop("city")# Removes key-value pair and returns value
p
print(f"Popped city:{popped_value}, Dict now:{my_dict}")# Output: Popped city: London,
Dict now: {'name': 'Bob', 'age': 26, 'country': 'UK'}
● S
ets (Mutable, Unordered, Unique Elements):
○ Creation:
Python
my_set = {1,2,3,3,4,2} # Duplicates are automatically removed
print(f"Created set:{my_set}") # Output: Created set: {1, 2, 3, 4} (order may vary)
○ A
dd:
Python
my_set.add(5)
print(f"After adding 5:{my_set}")# Output: After adding 5: {1, 2, 3, 4, 5}
my_set.add(3) # Adding an existing element does nothing
print(f"After adding 3 again:{my_set}") # Output: After adding 3 again: {1, 2, 3, 4, 5}
○ R
emove:
Python
my_set.remove(1)
print(f"After removing 1:{my_set}") # Output: After removing 1: {2, 3, 4, 5}
# my_set.remove(99) # This would raise a KeyError if 99 is not in the set
my_set.discard(99)# discard() does not raise an error if element not found
print(f"After discarding 99:{my_set}")# Output: After discarding 99: {2, 3, 4, 5}
○ S
et operations: union(), intersection(), difference()
Python
set_a = {1,2,3,4}
set_b = {3,4,5,6}
rint(f"Union (A | B):{set_a.union(set_b)}")
p # Output: Union (A | B): {1, 2, 3, 4, 5, 6}
print(f"Intersection (A & B):{set_a.intersection(set_b)}")# Output: Intersection (A & B): {3, 4}
print(f"Difference (A - B):{set_a.difference(set_b)}") # Output: Difference (A - B): {1, 2}
print(f"Symmetric Difference (A ^ B):{set_a.symmetric_difference(set_b)}") # Output:
Symmetric Difference (A ^ B): {1, 2, 5, 6}
4. Control Flow
● if, elif, else:
Python
temperature =25
iftemperature >30:
print("It's hot outside!")
eliftemperature >20:
print("It's a pleasant day.")# This will be executed
else:
print("It's a bit chilly.")
# Output: It's a pleasant day.
● f or loops (Iteration):
Python
# Iterating over a list
fruits = ["apple","banana","cherry"]
print("Iterating through fruits:")
forfruitinfruits:
print(fruit)
Output:
#
# apple
# banana
# cherry
# Using range()
print("Using range():")
foriinrange(5
):# 0, 1, 2, 3, 4
print(i)
# Output: 0, 1, 2, 3, 4 (each on a new line)
print("Using range(start, stop, step):")
foriinrange(1 ,10,2) :# 1, 3, 5, 7, 9
print(i)
# Output: 1, 3, 5, 7, 9 (each on a new line)
# Iterating over dictionary items
person = {"name":"Charlie","age":40}
forkey, valuein[Link]():
print(f"{key}:{value}")
Output:
#
# name: Charlie
# age: 40
● w
hile loops (Conditional Iteration):
Python
count =0
whilecount <3:
print(f"Count is{count}")
count +=1
Output:
#
# Count is 0
# Count is 1
# Count is 2
● b
reak and continue:
○ break: Exits the loop immediately.
Python
print("Using break:")
foriinrange(1 0):
ifi ==5:
break# Exit the loop when i is 5
print(i)
Output:
#
# 0
# 1
# 2
# 3
# 4
○ c
ontinue: Skips the rest of the current iteration and moves to the next.
Python
print("Using continue:")
foriinrange(5
):
ifi %2==0:# If i is even
continue # Skip the print statement for even numbers
print(i)
Output:
#
# 1
# 3
5. Functions
● F
unction Definition (def):
Python
defmy_function(parameter1, parameter2=None):
"""Docstring: Explains what the function does.
param1: (Required) A description of parameter1.
param2: (Optional) A description of parameter2 with its default value.
"""
# Function body: code executed when the function is called
print(f"Inside my_function: param1={parameter1}, param2={parameter2}")
returnparameter1 *2
● C
alling a Function:This is how you execute the code defined within a function. You use
the function's name followed by parentheses () containing any required arguments.
Python
# Calling my_function with only the required argument
result1 = my_function(10)
print(f"Result of first call:{result1}")
Output:
#
# Inside my_function: param1=10, param2=None
# Result of first call: 20
# Calling my_function with both arguments
result2 = my_function("Hello","World")
print(f"Result of second call:{result2}")
Output:
#
# Inside my_function: param1=Hello, param2=World
# Result of second call: HelloHello
# Calling a function with keyword arguments
print(my_function(parameter2="Value2", parameter1=5) )
# Output:
# Inside my_function: param1=5, param2=Value2
# Result of third call: 10
● A
rguments:
○ Positional arguments (as shown above)
K
○ eyword arguments (as shown above)
○ Arbitrary positional arguments (*args): Gathers all remaining positional arguments
into a tuple.
Python
deffunc_with_args(*args):
print(f"Args received:{args}")
func_with_args(1,2,"hello",True)
# Output: Args received: (1, 2, 'hello', True)
○ A
rbitrary keyword arguments (**kwargs): Gathers all remaining keyword arguments
into a dictionary.
Python
deffunc_with_kwargs(**kwargs):
print(f"Kwargs received:{kwargs}")
func_with_kwargs(name="David", age=30, city="Hyderabad")
# Output: Kwargs received: {'name': 'David', 'age': 30, 'city': 'Hyderabad'}
○ C
ombining all argument types:
Python
deffunc_with_all(required_param, *args, default_param="default", **kwargs):
print(f"Required Param:{required_param}")
rint(f"Positional Args (*args):{args}")
p
print(f"Default Param:{default_param}")
print(f"Keyword Args (**kwargs):{kwargs}")
func_with_all("first",10,20, item="laptop", price=1200)
Output:
#
# Required Param: first
# Positional Args (*args): (10, 20)
# Default Param: default
# Keyword Args (**kwargs): {'item': 'laptop', 'price': 1200}
● R
eturn Values:Functions can send data back using the return statement.
Python
defcalculate_area(length, width):
area = length * width
returnarea# Returns the calculated area
r oom_area = calculate_area(5,8)
print(f"The area of the room is:{room_area}square units.")# Output: The area of the room is: 40
square units.
● L
ambda Functions (Anonymous functions):Small, single-expression functions.
○ Python
add =lambdax, y: x + y
print(f"Lambda add(2, 3):{add(2,3)}")# Output: Lambda add(2, 3): 5
# Using lambda with sorted() for custom sorting
points = [(1,2) , (0,5), (3,1) ]
# Sort by the second element of each tuple
s orted_points =sorted(points, key=lambdapoint: point[1] )
print(f"Sorted points by y-coord:{sorted_points}") # Output: Sorted points by y-coord: [(3,
1), (1, 2), (0, 5)]
6. Input/Output
● I nput from user:name = input("Enter your name: ") (returns a string)
Python
user_name = input("Please enter your name: ")
#
# print(f"Hello, {user_name}!")
# Example interaction:
# Please enter your name: Gini
# Hello, Gini!
Example: Taking integer input (requires type conversion)
#
# num_str = input("Enter a number: ")
# num = int(num_str) # Convert string to integer
# print(f"You entered: {num}, Type: {type(num)}")
● P
rint to console (print()):
○ Basic printing:
Python
print("Hello, World!")# Output: Hello, World!
○ f -string formatting (formatted string literals - modern and recommended):
Python
user_name ="Eve"
user_age =28
print(f"User:{user_name}, Age:{user_age}") # Output: User: Eve, Age: 28
○ U
sing sep and end arguments:
Python
item_price =150.00
print("Product:","Laptop","Price:", item_price, sep=" | ", end=".\n")
# Output: Product: | Laptop | Price: | 150.0.
print("This is on a new line because of previous 'end'.")
○ O
ld-style % formatting (less common now):
Python
print("My name is %s and I am %d years old."% ("Frank",35))
# Output: My name is Frank and I am 35 years old.
○ .format() method (still widely used):
Python
print("My name is {} and I am {} years old.".f ormat(" Grace",22))
# Output: My name is Grace and I am 22 years old.
7. File Handling
● O
pening a file:
Python
It's best practice to use 'with' statement for file handling.
#
# It ensures the file is automatically closed even if errors occur.
try:
# 'w' mode for writing (creates new file or truncates existing)
withopen("[Link]","w")asfile:
[Link]("Hello, Python!\n")
fi
[Link]("This is a new line.\n")
print("Successfully wrote to [Link]")
# 'r' mode for reading
withopen("[Link]","r")asfile:
ontent = [Link]()
c
print("\nContent of [Link]:")
print(content)
# 'a' mode for appending (adds to end of file)
withopen("[Link]","a")asfile:
[Link]("Appending another line.\n")
fi
print("\nSuccessfully appended to [Link]")
withopen("[Link]","r")asfile:
ontent_after_append = [Link]()
c
print("\nContent after append:")
print(content_after_append)
exceptIOErrorase:
print(f"Error handling file:{e}")
# After running this, a file named '[Link]' will be created/modified in the same directory.
○ M
odes:
■ "r": Read (default)
■ "w": Write (creates new file or truncates existing)
■ "a": Append (adds to end of file)
■ "x": Exclusive creation (fails if file exists)
Python
try:
#
# with open("new_exclusive_file.txt", "x") as file:
# [Link]("This file was created exclusively.")
# print("new_exclusive_file.txt created successfully.")
# except FileExistsError:
# print("new_exclusive_file.txt already exists!")
■ " b": Binary mode (e.g., for images, rb, wb)
Python
with open("[Link]", "rb") as img_file:
#
# binary_data = img_file.read()
# # process binary_data
"t": Text mode (default)
■
Reading:
●
○ [Link](): Reads entire file content as a single string.
Python
# Already shown in the example above.
○ fi
[Link](): Reads one line at a time.
Python
withopen("[Link]","r")asfile:
first_line = [Link]()
second_line = [Link]()
print(f"First line:{first_line.strip()}")
print(f"Second line:{second_line.strip()}")
Output (after previous writes):
#
# First line: Hello, Python!
# Second line: This is a new line.
○ fi
[Link](): Reads all lines into a list of strings.
Python
withopen("[Link]","r")asfile:
all_lines = [Link]()
print("All lines as a list:")
forlineinall_lines:
print([Link]())# .strip() removes trailing newline characters
Output (after previous writes):
#
# All lines as a list:
# Hello, Python!
# This is a new line.
# Appending another line.
● W
riting:
○ [Link](string): Writes a string to the file.
Python
# Already shown in the examples for "w" and "a" modes above.
8. Error Handling (Try-Except)
Python
try:
# Code that might raise an exception
num1 =int(input(" Enter a numerator: "))
num2 =int(input(" Enter a denominator: "))
result = num1 / num2
print(f"Result of division:{result}")
exceptZeroDivisionError:
print("Error: Cannot divide by zero!")
exceptValueError:
print("Error: Invalid input. Please enter integers only.")
exceptExceptionase:# Catch any other unexpected exceptions
print(f"An unexpected error occurred:{e}")
else:
# Code to run if no exceptions occurred in the 'try' block
print("Division successful, no errors encountered.")
nally:
fi
# Code that always runs, regardless of exceptions
print("Execution of the division attempt finished.")
print("\n--- Example with a successful run ---")
try:
x =10
y =2
z = x / y
print(f"Result:{z}")
exceptZeroDivisionError:
print("Caught ZeroDivisionError!")
exceptValueError:
print("Caught ValueError!")
else:
print("No exceptions in this successful try block.")
finally:
print("Finally block executed for successful run.")
Example interaction and output for division:
#
# Enter a numerator: 10
# Enter a denominator: 0
# Error: Cannot divide by zero!
# Execution of the division attempt finished.
Enter a numerator: abc
#
# Enter a denominator: 5
# Error: Invalid input. Please enter integers only.
# Execution of the division attempt finished.
Enter a numerator: 10
#
# Enter a denominator: 2
# Result of division: 5.0
# Division successful, no errors encountered.
# Execution of the division attempt finished.
9. Object-Oriented Programming (OOP)
● C
lass Definition (class):This is the blueprint for creating objects (instances).
Python
classDog:
# Class variable: shared by all instances of the class
species ="Canis familiaris"
# Constructor (`__init__`): Special method called when a new object is created.
def__init__(self, name, age):
"""
Initializes a new Dog object.
'self' refers to the instance being created/operated on.
"""
[Link] = name # Instance attribute (unique to each object)
[Link] = age # Instance attribute
print(f"A new dog named{[Link]}has been created!")
# Instance Method: operates on the object's instance attributes.
defbark(self):
"""Returns a string indicating the dog's bark."""
returnf"{[Link]}says Woof!"
# Another Instance Method
defget_age_in_dog_years(self):
"""Calculates the dog's age in 'dog years'."""
return[Link] *7
# Static Method (`@staticmethod`):
# Does not take `self` or `cls`. Behaves like a regular function
# but is logically related to the class.
staticmethod
@
defdescribe_dog_breed():
"""Provides a general description about dogs."""
return"Dogs are loyal companions."
# Class Method (`@classmethod`):
# Takes the class itself (`cls`) as the first argument.
Often used as alternative constructors or for methods that operate on class-level data.
#
@classmethod
defcreate_ancient_dog(cls, name):
"""Creates a Dog instance with a default 'ancient' age."""
returncls(name,100)# `cls(name, 100)` is equivalent to `Dog(name, 100)`
● O
bject Instantiation (Creating Instances):This is the act of creating anobject(a
specific instance) from aclassblueprint.
Python
# Creating instances (objects) of the Dog class
my_dog = Dog("Buddy",5)# Calls the __init__ method
your_dog = Dog("Lucy",2)
Output:
#
# A new dog named Buddy has been created!
# A new dog named Lucy has been created!
● A
ccessing Attributes/Methods:
Python
# Accessing instance attributes
print(f"My dog's name:{my_dog.name}") # Output: My dog's name: Buddy
print(f"Your dog's age:{your_dog.age}") # Output: Your dog's age: 2
# Accessing class variables
print(f"Species (from class):{[Link]}") # Output: Species (from class): Canis
familiaris
print(f"My dog's species (from instance):{my_dog.species}") # Output: My dog's species (from
instance): Canis familiaris
# Calling instance methods
rint(my_dog.bark())
p # Output: Buddy says Woof!
print(your_dog.get_age_in_dog_years()) # Output: 14 (2 * 7)
# Calling static methods (can be called via class or instance, but class is common)
print(Dog.describe_dog_breed()) # Output: Dogs are loyal companions.
print(my_dog.describe_dog_breed()) # Output: Dogs are loyal companions.
# Calling class methods
ncient_dog = Dog.create_ancient_dog("Fido")# Calls the create_ancient_dog class method
a
print(f"Ancient dog's name:{ancient_dog.name}, age:{ancient_dog.age}")
Output:
#
# A new dog named Fido has been created!
# Ancient dog's name: Fido, age: 100
● I nheritance:Creating a new class (subclass/child) from an existing class
(superclass/parent), inheriting its attributes and methods.
Python
classLabrador(Dog):# Labrador inherits from Dog
def__init__(self, name, age, color):
super().__init__(name, age)# Call the parent class's constructor
[Link] = color
defretrieve(self):
returnf"{[Link]}is retrieving the ball!"
olden = Labrador("Goldie",3,"Golden")
g
print(f"New Labrador:{[Link]}, Age:{[Link]}, Color:{[Link]}")
print([Link]()) # Inherited method
print([Link]()) # New method
Output:
#
# A new dog named Goldie has been created!
# New Labrador: Goldie, Age: 3, Color: Golden
# Goldie says Woof!
# Goldie is retrieving the ball!
● Polymorphism:Objects of different classes can be treated uniformly if they share a
ommon interface (e.g., method names).
c
Python
classCat:
defmake_sound(self):
return"Meow!"
classCow:
defmake_sound(self):
return"Moo!"
We need to ensure Dog also has a make_sound method for this example to work fully
#
classNewDog(Dog):# A slightly modified Dog class for this example
defmake_sound(self):
return[Link]()# Reusing the bark logic
y_pet = Cat()
m
farm_animal = Cow()
my_new_dog = NewDog("Sparky",4)# Instantiate the NewDog
defanimal_sound(animal):
print(animal.make_sound())
rint("\n--- Polymorphism Example ---")
p
animal_sound(my_pet) # Output: Meow!
animal_sound(farm_animal) # Output: Moo!
animal_sound(my_new_dog) # Output: Sparky says Woof!
● E
ncapsulation:Bundling data (attributes) and methods that operate on the data within a
single unit (class). Access control (e.g., private attributes using __).
Python
classBankAccount:
def__init__(self, balance):
self.__balance = balance# __balance is a "private" attribute (name mangling)
defdeposit(self, amount):
ifamount >0:
self.__balance += amount
print(f"Deposited{amount}. New balance:{self.__balance}")
else:
print("Deposit amount must be positive.")
defwithdraw(self, amount):
if0< amount <= self.__balance:
self.__balance -= amount
print(f"Withdrew{amount}. New balance:{self.__balance}")
else:
print("Invalid withdrawal amount or insufficient funds.")
defget_balance(self):
returnself.__balance
ccount = BankAccount(100)
a
[Link](50) # Output: Deposited 50. New balance: 150
[Link](30) # Output: Withdrew 30. New balance: 120
print(f"Current balance:{account.get_balance()}") # Output: Current balance: 120
print(account.__balance) # This will raise an AttributeError, demonstrating encapsulation
#
# print(account._BankAccount__balance) # Can still be accessed, but convention says don't.
● D
under Methods (Magic Methods):Special methods identified by double underscores
(__method__) that allow Python classes to interface with built-in functions and operators.
○ __str__(self): Defines the informal string representation of an object, returned by str()
and print(). Should be readable for end-users.
Python
classBook:
def__init__(self, title, author, pages):
s [Link] = title
[Link] = author
[Link] = pages
def__str__(self):
returnf'"{[Link]}" by{[Link]}'
def__repr__(self):
returnf"Book('{[Link]}', '{[Link]}',{[Link]})"
ook = Book("The Hitchhiker's Guide to the Galaxy","Douglas Adams",193)
b
print(book)# Uses __str__ # Output: "The Hitchhiker's Guide to the Galaxy" by Douglas
Adams
○ _ _repr__(self): Defines the "official" string representation of an object, returned by
repr() and used in interactive environments (like IDLE/Jupyter). Should be
unambiguous and, if possible, allow recreation of the object.
Python
# (Continued from Book example above)
book_repr =repr(book)
print(book_repr)# Uses __repr__ # Output: Book('The Hitchhiker\'s Guide to the Galaxy',
'Douglas Adams', 193)
# eval(book_repr) would ideally recreate the object if all constructor args are representable
○ _ _len__(self): Defines behavior for len().
Python
classMyCollection:
def__init__(self, items):
[Link] = items
def__len__(self):
returnlen([Link])
collection = MyCollection([1,2,3,4,5])
print(f"Length of collection:{len(collection)}") # Output: Length of collection: 5
○ __add__(self, other): Defines behavior for the+operator.
lass Vector:
c
def init(self, x, y):
self.x = x
self.y = y
def add(self, other):
return Vector(self.x + other.x, self.y1 + other.y)
def str(self):2 # For easy printing
return f"Vector({self.x}, {self.y})"
v 1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2 # Calls v1.__add__(v2)
print(f"v1 + v2 = {v3}") # Output: v1 + v2 = Vector(4, 6)
̀ ``
* Many more dunder methods exist for comparison (`__eq__`, `__lt__`), iteration (`__iter__`,
̀ __next__`), attribute access (`__getattr__`, `__setattr__`), callables (`__call__`), etc.
10. Useful Built-in Functions
● len(iterable): Returns the length of an object (list, string, tuple, dict, set).
Python
my_list = [10,20,30]
my_string ="Python"
my_dict = {"a":1,"b":2}
rint(f"Length of list:{len(my_list)}") # Output: Length of list: 3
p
print(f"Length of string:{len(my_string)}") # Output: Length of string: 6
print(f"Length of dictionary:{len(my_dict)}") # Output: Length of dictionary: 2
● t ype(object): Returns the type of an object.
Python
num =123
text ="abc"
is_true =True
print(f"Type of num:{t ype(num)}") # Output: Type of num: <class 'int'>
print(f"Type of text:{t ype(text)}") # Output: Type of text: <class 'str'>
print(f"Type of is_true:{type(is_true)}") # Output: Type of is_true: <class 'bool'>
● s tr(), int(), float(), bool(): Type conversion.
Python
num_str ="123"
num_int =int(num_str)
print(f"'{num_str}' as int:{num_int}, Type:{t ype(num_int)}") # Output: '123' as int: 123, Type: <class
'int'>
int_val =45
str_val =str(int_val)
print(f"{int_val}as str: '{str_val}', Type:{t ype(str_val)}") # Output: 45 as str: '45', Type: <class 'str'>
oat_val =float("3.14")
fl
print(f"'3.14' as float:{float_val}, Type:{t ype(float_val)}") # Output: '3.14' as float: 3.14, Type: <class
'float'>
z ero =0
empty_string =""
list_val = [1]
print(f"bool(0):{b ool(zero)}") # Output: bool(0): False
print(f"bool(''):{b
ool(empty_string)}") # Output: bool(''): False
print(f"bool([1]):{b ool(list_val)}") # Output: bool([1]): True
● r ange(start, stop, step): Generates a sequence of numbers (used in for loops).
Python
# Already covered in for loops, but here's a direct example:
my_range =range(3,10,2) # Start at 3, stop before 10, step by 2
print(f"Numbers in range(3, 10, 2):{list(my_range)}") # Output: Numbers in range(3, 10, 2): [3, 5, 7,
9]
● min(), max(), sum(): For numerical iterables.
ython
P
numbers = [10,5,8,12,3]
print(f"Min:{m
in(numbers)}")# Output: Min: 3
print(f"Max:{m
ax(numbers)}")# Output: Max: 12
print(f"Sum:{sum(numbers)}")# Output: Sum: 38
● a
bs(): Absolute value.
Python
print(f"Absolute value of -5:{a bs(-5) }")# Output: Absolute value of -5: 5
print(f"Absolute value of 5:{abs(5) }") # Output: Absolute value of 5: 5
● r ound(): Round to the nearest integer.
Python
print(f"round(3.14):{r ound(3.14)}") # Output: round(3.14): 3
print(f"round(3.7):{r ound(3.7)}") # Output: round(3.7): 4
print(f"round(2.5):{round(2.5)}") # Output: round(2.5): 2 (rounds to nearest even)
print(f"round(3.5):{r ound(3.5)}") # Output: round(3.5): 4
print(f"round(3.14159, 2):{round(3 .14159,2) }") # Output: round(3.14159, 2): 3.14
● e
numerate(): Iterate with an index.
Python
items = ["a","b","c"]
forindex, valueinenumerate(items):
print(f"Index{index}:{value}")
Output:
#
# Index 0: a
# Index 1: b
# Index 2: c
● z ip(): Combine multiple iterables.
Python
names = ["Alice","Bob"]
ages = [25,30]
forname, ageinzip(names, ages):
print(f"{name}is{age}years old.")
Output:
#
# Alice is 25 years old.
# Bob is 30 years old.
● m
ap(): Apply a function to all items in an iterable.
Python
defsquare(num):
returnnum * num
numbers = [1,2,3,4]
s quared_numbers =list(map(square, numbers))
print(f"Squared numbers (map):{squared_numbers}")# Output: Squared numbers (map): [1, 4, 9,
1 6]
# Often replaced by list comprehensions for readability
● fi
lter(): Filter items from an iterable based on a function.
Python
defis_even(num):
returnnum %2==0
umbers = [1,2,3,4,5,6]
n
even_numbers_filtered =list(fi lter(is_even, numbers))
print(f"Even numbers (filter):{even_numbers_filtered}") # Output: Even numbers (filter): [2, 4, 6]
# Often replaced by list comprehensions for readability
● s orted(): Returns a new sorted list from the items in an iterable.
Python
unsorted_list = [3,1,4,1,5,9,2]
sorted_list =sorted(unsorted_list)
print(f"Sorted list:{sorted_list}")# Output: Sorted list: [1, 1, 2, 3, 4, 5, 9]
# Custom sort key with lambda (as seen before)
words = ["banana","apple","cherry"]
s orted_by_length =sorted(words, key=len)
print(f"Sorted by length:{sorted_by_length}") # Output: Sorted by length: ['apple', 'banana',
'cherry']
● r eversed(): Returns a reverse iterator.
Python
my_list = [1,2,3,4]
reversed_list =list(r eversed(my_list))
print(f"Reversed list:{reversed_list}")# Output: Reversed list: [4, 3, 2, 1]
● a
ny(), all():
○ any(): Returns True ifanyelement of the iterable is true.
○ all(): Returns True ifallelements of the iterable are true.
ython
P
bool_list1 = [True,False,True]
bool_list2 = [False,False,False]
bool_list3 = [True,True,True]
rint(f"any({bool_list1}):{a
p ny(bool_list1)}") # Output: any([True, False, True]): True
print(f"any({bool_list2}):{a ny(bool_list2)}")# Output: any([False, False, False]): False
print(f"all({bool_list1}):{a
ll(bool_list1)}")# Output: all([True, False, True]): False
print(f"all({bool_list3}):{a
ll(bool_list3)}")# Output: all([True, True, True]): True
11. List, Dictionary, and Set Comprehensions
● L
ist Comprehensions:(Already covered, but good to reiterate here)
Python
squares = [x**2forxinrange(5 )]
print(f"Squares:{squares}") # Output: Squares: [0, 1, 4, 9, 16]
ltered_list = [xforxin[1 ,2,3,4,5]ifx %2!=0]
fi
print(f"Filtered odd numbers:{filtered_list}")# Output: Filtered odd numbers: [1, 3, 5]
● D
ictionary Comprehensions:
Python
keys = ["a","b","c"]
values = [1,2,3]
my_dict_comp = {k: vfork, vinzip(keys, values)}
print(f"Dict comprehension:{my_dict_comp}")# Output: Dict comprehension: {'a': 1, 'b': 2, 'c': 3}
s quared_dict = {num: num**2fornuminrange(1 ,4) }
print(f"Squared dict:{squared_dict}")# Output: Squared dict: {1: 1, 2: 4, 3: 9}
● S
et Comprehensions:
Python
unique_squares = {x**2forxin[-1,1,2, -2] }# Duplicates are removed automatically
print(f"Set comprehension:{unique_squares}") # Output: Set comprehension: {1, 4} (order may
vary)
12. String Methods
● s [Link](), [Link](), [Link](), [Link](delimiter),
[Link](list_of_strings), [Link](old, new), [Link](substring),
[Link](prefix), [Link](suffix): (Examples already provided in earlier
section, these remain essential).
○ Additional useful string methods:
■ [Link](substring): Returns the number of occurrences of a substring.
Python
text ="banana"
print(f"Count of 'a' in 'banana':{[Link]('a')}")# Output: Count of 'a' in 'banana': 3
■ s [Link](), [Link](), [Link](): Check character types.
Python
print(f"'123'.isdigit():{'123'.isdigit()}") # Output: '123'.isdigit(): True
rint(f"'abc'.isalpha():{'abc'.isalpha()}") # Output: 'abc'.isalpha(): True
p
print(f"'ab1'.isalnum():{'ab1'.isalnum()}") # Output: 'ab1'.isalnum(): True
print(f"'abc '.isalpha():{'abc '.isalpha()}") # Output: 'abc '.isalpha(): False (because of
space)
■ s [Link](), [Link](): Capitalize first letter or each word.
Python
print(f"'hello world'.capitalize():{'hello world'.capitalize()}") # Output: 'hello
world'.capitalize(): Hello world
print(f"'hello world'.title():{'hello world'.title()}") # Output: 'hello world'.title(): Hello
World
13. Modules and Packages
● I mporting a module:import math
Python
importmath
print(f"Square root of 16:{[Link](16)}")# Output: Square root of 16: 4.0
print(f"Pi value:{[Link]}") # Output: Pi value: 3.141592653589793
● I mporting specific items:from datetime import date
Python
fromdatetimeimportdate, timedelta
today = [Link]()
print(f"Today's date:{today}")# Output: Today's date: 2025-06-10 (or current date)
t omorrow = today + timedelta(days=1)
print(f"Tomorrow's date:{tomorrow}")# Output: Tomorrow's date: 2025-06-11 (or tomorrow's
date)
● A
liasing imports:import numpy as np
Python
For this to run, you'd typically need to install numpy: pip install numpy
#
# import numpy as np
# arr = [Link]([1, 2, 3])
# print(f"Numpy array: {arr}")
● I nstalling packages:pip install package_name
Bash
To install a package like 'requests' (for making HTTP requests):
#
# pip install requests
# Then you can import and use it in your Python code:
import requests
#
# response = [Link]("[Link]
# print(f"Google status code: {response.status_code}")
14. Advanced Concepts
● D
ecorators:Functions that modify or enhance other functions.
Python
defmy_decorator(func):
defwrapper():
rint("Something is happening before the function is called.")
p
func()
print("Something is happening after the function is called.")
returnwrapper
my_decorator# Syntactic sugar for say_hello = my_decorator(say_hello)
@
defsay_hello():
print("Hello!")
s ay_hello()
# Output:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.
● G
enerators (yield):Functions that return an iterator that produces a sequence of results
on demand, instead of building a full list in memory.
Python
defcount_up_to(max_num):
count =1
whilecount <= max_num:
yieldcount# Pauses execution and yields a value
count +=1
y_generator = count_up_to(3)
m
print(f"First yield:{next(my_generator)}") # Output: First yield: 1
print(f"Second yield:{next(my_generator)}")# Output: Second yield: 2
print("Looping through the rest:")
fornuminmy_generator:
print(num)
Output:
#
# Looping through the rest:
# 3
● C
ontext Managers (with statement):Ensures resources are properly acquired and
released (e.g., files, locks). Uses __enter__ and __exit__ methods.
Python
Example (File handling is the most common built-in context manager)
#
# Shown in File Handling section:
# with open("[Link]", "w") as f:
# [Link]("Hello")
Custom context manager example:
#
classMyContext:
def__enter__(self):
print("Entering the context")
returnself
def__exit__(self, exc_type, exc_val, exc_tb):
print("Exiting the context")
ifexc_type:# If an exception occurred
print(f"An exception occurred:{exc_val}")
returnFalse# Propagate the exception if it happened
withMyContext()asmc:
print("Inside the context")
raise ValueError("Something went wrong!") # Uncomment to see exception handling
#
# Output:
# Entering the context
# Inside the context
# (If ValueError was uncommented: An exception occurred: Something went wrong!)
# Exiting the context
● I terators:Objects that implement __iter__() and __next__() methods, allowing them to be
iterated over (e.g., in for loops).
Python
classMyRangeIterator:
def__init__(self, limit):
[Link] = limit
[Link] =0
def__iter__(self):
returnself
def__next__(self):
if[Link] < [Link]:
[Link] +=1
return[Link]
else:
raiseStopIteration
print("\n--- Custom Iterator Example ---")
fornuminMyRangeIterator(3) :
print(f"Iterated:{num}")
Output:
#
# Iterated: 1
# Iterated: 2
# Iterated: 3
● D
escriptors:Protocol for how attribute access works, allowing customization of attribute
behavior (advanced OOP).
Python
classTen:
def__get__(self, obj, objtype=None):
return10
def__set__(self, obj, value):
print(f"Cannot set 'Ten' directly, trying to set{value}")
# Usually, you'd raise an AttributeError or handle it.
# For demonstration, we'll allow setting but show the message.
# To truly prevent setting, you'd typically raise AttributeError.
obj.__dict__['x'] = value# Sets directly on the instance's dictionary
classA:
x = Ten()# x is now a descriptor
_instance = A()
a
print(f"Accessing a_instance.x (via descriptor):{a_instance.x}")# Output: Accessing a_instance.x
(via descriptor): 10
a_instance.x =20# Calls Ten.__set__
# Output: Cannot set 'Ten' directly, trying to set 20
print(f"Accessing a_instance.x after assignment:{a_instance.x}")# Output: Accessing
a_instance.x after assignment: 20
# Note: If __set__ was not defined, a.x = 20 would create an instance attribute named 'x' that
shadows the descriptor.
● M
etaclasses:Classes that create classes. They allow you to customize class creation.
Python
Very advanced, often used in frameworks.
#
classMyMeta(type):
def__new__(mcs, name, bases, attrs):
print(f"Metaclass: Creating class{name}")
# Add a default attribute to all classes created with this metaclass
attrs['creation_info'] =f"Class{name}created by MyMeta"
returnsuper().__new__(mcs, name, bases, attrs)
classMyClass(metaclass=MyMeta):
pass
classAnotherClass(MyClass):# This class also uses MyMeta via inheritance
pass
rint(MyClass.creation_info) # Output: Class MyClass created by MyMeta
p
print(AnotherClass.creation_info)# Output: Class AnotherClass created by MyMeta
● A
synchronous Programming (async/await):For concurrent execution without using
threads, primarily for I/O-bound tasks.
○ async: Defines a coroutine, which is a function that can pause its execution and
resume later.
○ await: Pauses the execution of the current coroutine until the awaited async
operation (like I/O) completes.
Python
importasyncio
importtime
asyncdeffetch_data(delay, data_id):
"""Simulates an asynchronous I/O operation (e.g., network request)."""
print(f"[{[Link]('%H:%M:%S')}] Start fetching data{data_id}(will take{delay}s)...")
await[Link](delay)# Pauses this coroutine, allows others to run
print(f"[{[Link]('%H:%M:%S')}] Finished fetching data{data_id}.")
returnf"Data{data_id}fetched successfully"
asyncdefmain():
"""The main asynchronous function to run."""
print(f"[{[Link]('%H:%M:%S')}] Starting main program.")
# Create tasks for concurrent execution
t ask1 = asyncio.create_task(fetch_data(3,1))# This task will take 3 seconds
task2 = asyncio.create_task(fetch_data(1,2) )# This task will take 1 second
task3 = asyncio.create_task(fetch_data(2,3) )# This task will take 2 seconds
# Await all tasks concurrently. `[Link]` waits for all of them.
# The order of results in `gathered_results` corresponds to the order of tasks.
gathered_results =await[Link](task1, task2, task3)
print(f"[{[Link]('%H:%M:%S')}] All data fetched:{gathered_results}")
print(f"[{[Link]('%H:%M:%S')}] Main program finished.")
To run an async function, you typically use [Link]()
#
# [Link](main())
# Example Output (timestamps will vary based on execution time):
# [Link] Starting main program.
# [Link] Start fetching data 1 (will take 3s)...
# [Link] Start fetching data 2 (will take 1s)...
# [Link] Start fetching data 3 (will take 2s)...
# [Link] Finished fetching data 2.
# [Link] Finished fetching data 3.
# [Link] Finished fetching data 1.
# [Link] All data fetched: ['Data 1 fetched successfully', 'Data 2 fetched successfully',
'Data 3 fetched successfully']
# [Link] Main program finished.
otice how tasks 2 and 3 finish before task 1, even though task 1 was started first.
N
This is because await [Link]() allows other tasks to run while one is "sleeping"
(waiting for I/O).
15. Common Design Patterns in Python
Design patterns are reusable solutions to common problems in software design.
● S
ingleton Pattern (Creational):Ensures a class has only one instance and provides a
global point of access to that instance.
Python
classSingleton:
_instance =None# Class-level attribute to hold the single instance
def__new__(cls, *args, **kwargs):
ifcls._instanceisNone:
rint("Creating the one and only Singleton instance...")
p
cls._instance =super().__new__(cls)
returncls._instance
def__init__(self, value):
# This __init__ will be called every time Singleton() is called,
# but the actual instance creation only happens once via __new__.
# So, handle initialization carefully for Singletons.
ifnothasattr(self,'_initialized'):# Prevent re-initialization
s [Link] = value
self._initialized =True
print(f"Singleton initialized with value:{[Link]}")
s1 = Singleton("First Value")
s2 = Singleton("Second Value")# This will not create a new instance, just re-call __init__
rint(f"s1 is s2:{s1iss2}") # Output: s1 is s2: True (they are the same object)
p
print(f"[Link]:{[Link]}") # Output: [Link]: First Value (if _initialized check is used)
print(f"[Link]:{[Link]}")# Output: [Link]: First Value
Output:
#
# Creating the one and only Singleton instance...
# Singleton initialized with value: First Value
# Singleton initialized with value: Second Value (if _initialized check not used)
# s1 is s2: True
# [Link]: First Value
# [Link]: First Value
● F
actory Method Pattern (Creational):Defines an interface for creating an object, but
lets subclasses decide which class to instantiate.3
Python
classDog:
defspeak(self):
return"Woof!"
classCat:
defspeak(self):
return"Meow!"
classAnimalFactory:
@staticmethod
defcreate_animal(animal_type):
ifanimal_type =="dog":
returnDog()
elifanimal_type =="cat":
returnCat()
else:
raiseValueError("Unknown animal type")
rint("\n--- Factory Pattern Example ---")
p
my_dog = AnimalFactory.create_animal("dog")
my_cat = AnimalFactory.create_animal("cat")
rint(my_dog.speak())# Output: Woof!
p
print(my_cat.speak())# Output: Meow!
● A
dapter Pattern (Structural):Allows objects with incompatible interfaces to
collaborate.
Python
Existing "legacy" system interface
#
classOldLogger:
deflog_message(self, msg):
print(f"Old Log:{msg}")
New system expects a different interface
#
classNewAnalyticsSystem:
defsend_event(self, event_name, data):
print(f"New Analytics: Event='{event_name}', Data={data}")
Adapter to make OldLogger compatible with NewAnalyticsSystem expectation
#
classLoggerToAnalyticsAdapter:
def__init__(self, logger):
[Link] = logger
defsend_event(self, event_name, data):
# Adapt the call: convert event to log message
dapted_message =f"Analytics Event:{event_name}, Data:{data}"
a
[Link].log_message(adapted_message)
rint("\n--- Adapter Pattern Example ---")
p
old_logger_instance = OldLogger()
analytics_system_instance = NewAnalyticsSystem()
# Direct call to new system
analytics_system_instance.send_event("UserLogin", {"user_id":123})
# Using the adapter to send an "event" through the old logger
dapter = LoggerToAnalyticsAdapter(old_logger_instance)
a
adapter.send_event("PageView", {"page":"/home"})
Output:
#
# Old Log: Analytics Event: PageView, Data: {'page': '/home'}
● B
uilder Pattern (Creational):Separates the construction of a complex object from its
representation, allowing the same construction process4 to create different
r epresentations.5
Python
classBurger:
def__init__(self):
s [Link] =None
[Link] =None
[Link] =None
[Link] = []
[Link] = []
def__str__(self):
return(f"Burger with:{[Link]}buns,{[Link]}patty, "
f"{'cheese'if[Link]else'no cheese'}, "
f"sauces:{', '.join([Link])if[Link]else'none'}, "
f"veg:{', '.join([Link])if[Link]else'none'}")
classBurgerBuilder:
def__init__(self):
[Link] = Burger()
defadd_buns(self, bun_type):
[Link] = bun_type
returnself# Allows chaining
defadd_patty(self, patty_type):
[Link] = patty_type
returnself
defadd_cheese(self):
[Link] =True
returnself
defadd_sauce(self, sauce_type):
[Link](sauce_type)
returnself
defadd_vegetable(self, veg_type):
[Link](veg_type)
returnself
defbuild(self):
return[Link]
print("\n--- Builder Pattern Example ---")
# Build a complex burger step-by-step
veg_burger = (BurgerBuilder()
.add_buns("whole wheat")
.add_patty("veggie")
.add_sauce("mayo")
.add_vegetable("lettuce")
.add_vegetable("tomato")
.build())
rint(veg_burger)
p
Output: Burger with: whole wheat buns, veggie patty, no cheese, sauces: mayo, veg: lettuce,
#
tomato
cheese_burger = (BurgerBuilder()
.add_buns("sesame")
.add_patty("beef")
.add_cheese()
.add_sauce("ketchup")
.add_sauce("mustard")
.build())
print(cheese_burger)
# Output: Burger with: sesame buns, beef patty, cheese, sauces: ketchup, mustard, veg: none
16. Architectural Patterns
These are broader structural patterns for organizing code, often at the application level.
● M
odel-View-Controller (MVC):Divides an application into three interconnected
components to separate concerns and improve maintainability.
○ Model:Manages the data and business logic. It notifies the View of any changes.
○ View:Displays the data from the Model to the user. It observes the Model for
changes.
○ Controller:Handles user input, interacts with the Model to update data, and
instructs the View to update its display.
Python
A very simplified conceptual example of MVC in Python.
#
# In a real application, these would be separate classes/modules.
1. Model (Data & Logic)
#
classDataModel:
def__init__(self):
self._data =0
self._observers = []# List of views/controllers observing this model
defadd_observer(self, observer):
self._observers.append(observer)
defset_data(self, value):
ifself._data != value:
self._data = value
self._notify_observers()
defget_data(self):
returnself._data
def_notify_observers(self):
forobserverinself._observers:
[Link]()
2. View (Presentation)
#
classTextView:
def__init__(self, model):
s elf._model = model
self._model.add_observer(self)# View observes the Model
defupdate(self):
# React to model changes and update display
print(f"View Updated: Data is now{self._model.get_data()}")
defdisplay(self):
print(f"Current View Display:{self._model.get_data()}")
3. Controller (Input Handling & Orchestration)
#
classDataController:
def__init__(self, model):
self._model = model
defincrement_data(self, amount=1) :
urrent_data = self._model.get_data()
c
self._model.set_data(current_data + amount)
defdecrement_data(self, amount=1):
urrent_data = self._model.get_data()
c
self._model.set_data(current_data - amount)
print("\n--- MVC Pattern Example ---")
# Setup
odel = DataModel()
m
view = TextView(model)
controller = DataController(model)
# Initial display
[Link]()# Output: Current View Display: 0
# User action via controller
controller.increment_data()
# Output: View Updated: Data is now 1
controller.increment_data(5)
# Output: View Updated: Data is now 6
controller.decrement_data(2)
# Output: View Updated: Data is now 4
[Link]()# Output: Current View Display: 4
his extended cheat sheet now thoroughly covers dunder methods, more design patterns,
T
and an introduction to architectural patterns, making it even more robust for Python
developers!
ources
S
1.[Link]
2.[Link]
3.[Link]
4.[Link]
5.[Link]
6.[Link]
7.[Link]
8.[Link]
9.[Link]
10.[Link]
11.[Link]
12.[Link]
13.[Link]
14.[Link]
15.
[Link]
development,522531?
16.[Link]
17.[Link]
18.[Link]
You might also like
- The Absolute Basics: Basic and Intermediate Python 3 - Notes/Cheat Sheet100% (4)The Absolute Basics: Basic and Intermediate Python 3 - Notes/Cheat Sheet11 pages
- 21cs15it Problem Solving and Python Programming Questions and AnswersNo ratings yet21cs15it Problem Solving and Python Programming Questions and Answers6 pages
- Python MCQs All Weeks Answers With StepsNo ratings yetPython MCQs All Weeks Answers With Steps29 pages
- Python Programming - Basics To AdvancedNo ratings yetPython Programming - Basics To Advanced107 pages
- Complete Python Notes - All Topics (Class 11)No ratings yetComplete Python Notes - All Topics (Class 11)16 pages
- Solution To Partial Differential EquationNo ratings yetSolution To Partial Differential Equation30 pages
- Data Science & Machine Learning BootcampNo ratings yetData Science & Machine Learning Bootcamp4 pages
- Cse 2nd Semester C Programming Notes Part 2No ratings yetCse 2nd Semester C Programming Notes Part 2111 pages
- C Programming Project Presentation LG-2No ratings yetC Programming Project Presentation LG-224 pages
- I Know You Want More .: Check Out These Awesome Activities!No ratings yetI Know You Want More .: Check Out These Awesome Activities!13 pages
- Real Time Crop Harvest Time Prediction Model Using Raspberry Pi and Image ProcessingNo ratings yetReal Time Crop Harvest Time Prediction Model Using Raspberry Pi and Image Processing6 pages
- One Hybrid Integration Solution: PT. Sintesa Inti MitraNo ratings yetOne Hybrid Integration Solution: PT. Sintesa Inti Mitra14 pages
- Yllana Bay View College, Inc.: Teaching Guide ForNo ratings yetYllana Bay View College, Inc.: Teaching Guide For4 pages
- Integrated Design and Construction ProcessNo ratings yetIntegrated Design and Construction Process30 pages
