🐍 Python: From Beginner to Advanced
1. 🔤 Variables
Overview:
● Variables are containers for storing data values. Python dynamically assigns the variable
type based on the value.
Example:
name = "Alice" # String
age = 25 # Integer
height = 5.7 # Float
Tip:
● 💡 Use meaningful variable names to enhance code readability.
2. ➕ Operators
Overview:
● Operators in Python are used to perform operations on variables and values.
Types:
● Arithmetic Operators: +, -, *, /, %, **, //
● Comparison Operators: ==, !=, >, <, >=, <=
● Logical Operators: and, or, not
● Assignment Operators: =, +=, -=, *=, /=
● Bitwise Operators: &, |, ^, ~, <<, >>
Example:
x = 10
y = 5
result = x + y # Arithmetic: 15
is_equal = (x == y) # Comparison: False
is_greater_and_even = (x > y) and (x % 2 == 0) # Logical: True
Tip:
● 💡 Combine operators for complex calculations or logic checks.
3. 🛠️ Functions
Overview:
● Functions are reusable blocks of code that perform a specific task.
Creating a Function:
def greet(name):
return f"Hello, {name}!"
Calling a Function:
print(greet("Alice")) # Output: Hello, Alice!
Tip:
● 💡 Use functions to reduce redundancy and improve code organization.
4. 📚 Libraries and Modules
Libraries:
● Python libraries are collections of pre-written code for common tasks. Examples include
NumPy, Pandas, and Matplotlib.
Example:
import math
result = math.sqrt(16) # Output: 4.0
Modules:
● A module is a file containing Python definitions and statements. Importing a module
allows you to use its functions and classes.
Creating a Module:
# mymodule.py
def greet(name):
return f"Hello, {name}!"
Using a Module:
import mymodule
print(mymodule.greet("Alice")) # Output: Hello, Alice!
Tip:
● 💡 Explore Python’s libraries and use modules to keep your code organized.
5. 📦 Packages
Overview:
● Packages are collections of modules organized in a directory hierarchy. They help
structure large projects.
Creating a Package:
Structure:
mypackage/
__init__.py
module1.py
module2.py
Tip:
● 💡 Use packages to logically organize your codebase for large projects.
6. 🧩 Methods
Overview:
● Methods are functions associated with objects. They operate on data contained in the
object.
Example:
text = "hello world"
print(text.upper()) # Output: HELLO WORLD
Tip:
● 💡 Learn common methods for strings, lists, and dictionaries to streamline your
coding.
7. 🛠️ Refactoring
Overview:
● Refactoring improves the structure of existing code without changing its behavior.
Techniques:
● Extract Method: Move repeated code into a function.
● Rename Variable: Use descriptive variable names.
● Simplify Expressions: Break down complex expressions.
Example:
# Before Refactoring
result = (x + y) * z
# After Refactoring
def calculate_sum_and_multiply(x, y, z):
return (x + y) * z
Tip:
● 💡 Regularly refactor your code for better readability and maintainability.
8. 🎨 Enum (Enumerations)
Overview:
● Enums are symbolic names for a set of values. They are used to define a fixed set of
constants.
Example:
from enum import Enum
class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3
Tip:
● 💡 Use Enums to handle fixed sets of values more effectively.
9. 📦 Tuples, Dictionaries, Sets
Tuples:
● Immutable ordered collections.
Example:
point = (10, 20)
Dictionaries:
● Key-value pairs for mapping data.
Example:
student = {"name": "Alice", "age": 25}
Sets:
● Unordered collections of unique elements.
Example:
unique_numbers = {1, 2, 3, 4, 5}
Tip:
● 💡 Use tuples for fixed data, dictionaries for key-value mapping, and sets for unique
collections.
10. 🔄 Map, Filter, Reduce
Map:
● Applies a function to all items in an input list.
Example:
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers)) # [1, 4, 9, 16]
Filter:
● Filters elements based on a function.
Example:
numbers = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, numbers)) # [2, 4]
Reduce:
● Reduces a list to a single value by applying a function cumulatively.
Example:
from functools import reduce
numbers = [1, 2, 3, 4]
total = reduce(lambda x, y: x + y, numbers) # Output: 10
Tip:
● 💡 Use map, filter, reduce for efficient data processing.
11. 🧱 Class & Objects
Overview:
● Python is object-oriented. Classes are blueprints for creating objects.
Creating a Class:
class Car:
def __init__(self, brand, model):
self.brand = brand
self.model = model
def drive(self):
return f"The {self.brand} {self.model} is driving."
my_car = Car("Toyota", "Corolla")
print(my_car.drive()) # Output: The Toyota Corolla is driving.
Tip:
● 💡 Use classes to encapsulate data and behavior.
12. 🧰 Exceptions
Overview:
● Exceptions handle runtime errors using try-except blocks.
Example:
try:
result = 10 / 0
except ZeroDivisionError:
print("You can't divide by zero!")
Tip:
● 💡 Use exceptions to handle errors gracefully and maintain program flow.
13. ⚙️ Overloading
Overview:
● Method overloading allows defining multiple methods with the same name but different
parameters.
Example:
class Calculator:
def add(self, a, b, c=None):
if c:
return a + b + c
return a + b
calc = Calculator()
print(calc.add(5, 10)) # Output: 15
print(calc.add(5, 10, 15)) # Output: 30
Tip:
● 💡 Use method overloading to increase function versatility.
14. 🔄 Iterators
Overview:
● An iterator allows you to traverse through all elements of a collection.
Creating an Iterator:
numbers = [1, 2, 3]
iterator = iter(numbers)
print(next(iterator)) # Output: 1
print(next(iterator)) # Output: 2
Tip:
● 💡 Use for loops to iterate over iterables without manually handling iterators.
15. ⚙️ Generators
Overview:
● Generators yield items one at a time, which is memory efficient.
Creating a Generator:
def count_up_to(max):
count = 1
while count <= max:
yield count
count += 1
counter = count_up_to(5)
for number in counter:
print(number)
Tip:
● 💡 Use generators for large datasets to optimize memory usage.
16. 📋 List Comprehensions
Overview:
● List comprehensions provide a concise way to create lists.
Example:
squares = [x**2 for x in range(10)]
Tip:
● 💡 Use list comprehensions for cleaner and more concise code.
17. 🔍 Regular Expressions
Overview:
● Regular expressions are used for string matching and manipulation.
Example:
import re
text = "The rain in Spain"
match = re.search(r"\bS\w+", text) # Matches 'Spain'
print(match.group()) # Output: Spain
Tip:
● 💡 Keep regex patterns simple for better readability.
18. 🔄 Serialization
Overview:
● Serialization converts an object into a format that can be easily saved or transmitted.
Example:
import json
data = {"name": "Alice", "age": 25}
json_data = json.dumps(data)
loaded_data = json.loads(json_data)
Tip:
● 💡 Use JSON for human-readable and easy-to-parse serialization.
19. 🎛️ Partial Functions
Overview:
● Partial functions allow you to fix some arguments of a function and create a new
function.
Example:
from functools import partial
def multiply(x, y):
return x * y
double = partial(multiply, 2)
print(double(5)) # Output: 10
Tip:
● 💡 Use partial functions to simplify frequently used functions.
20. 🔒 Closures
Overview:
● A closure is a function that remembers values in its enclosing scope even if they are not
present in memory.
Example:
def outer_function(msg):
def inner_function():
print(msg)
return inner_function
greet = outer_function("Hello")
greet() # Output: Hello
Tip:
● 💡 Use closures to create functions with preserved state.
21. 🎨 Decorators
Overview:
● Decorators modify the behavior of a function or class.
Creating a Decorator:
def my_decorator(func):
def wrapper():
print("Before the function.")
func()
print("After the function.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()
Tip:
● 💡 Use decorators to add reusable code functionality without modifying the original
function.
🚀
This comprehensive guide brings together essential concepts from Python’s beginner to
advanced levels, providing a solid foundation for mastering the language. Happy coding!
