Control Flow: Decisions and Loops

Control flow is essential for creating dynamic and responsive programs. Python provides powerful tools for decision-making and iteration.

If-Else Statements

Use if, elif (else if), and else statements to make decisions based on conditions.

if condition1:
  # Code to execute if condition1 is True
elif condition2:
  # Code to execute if condition2 is True
else:
  # Code to execute if neither condition1 nor condition2 is True

Loops

Python offers two types of loops: for and while.

For Loop

Iterate over a sequence (list, tuple, string) using a for loop.

fruits = ["apple", "banana", "orange"]
for fruit in fruits:
  print(fruit)

While Loop

Execute a block of code while a condition is True using a while loop.

i = 1
while i <= 5:
  print(i)
  i += 1

Functions: Building Blocks of Python

Functions are reusable blocks of code that perform specific tasks. They are fundamental to modular and efficient programming.

Defining a Function

Use the def keyword to define a function. Functions can have parameters and return values.

def greet(name):
  return "Hello, " + name

Calling a Function

Invoke a function by its name and provide the required arguments.

result = greet("Alice")
print(result)

Function Parameters

Functions can accept parameters, allowing them to be versatile and adaptable.

def calculate(a, b, operator):
  if operator == "add":
    return a + b
  elif operator == "subtract":
    return a - b
  else:
    return "Invalid operator"

Lists and Tuples: Managing Data Collections

Python's data structures, such as lists and tuples, are powerful tools for managing collections of data.

Lists

Lists are mutable sequences of elements. They can store elements of different data types.

my_list = [1, "apple", True]

Tuples

Tuples are immutable sequences, meaning their elements cannot be modified once created.

my_tuple = (1, "apple", True)

Operations on Lists and Tuples

Python provides various methods and operators for manipulating lists and tuples.

• Accessing Elements: Use indexing (my_list[index]) to access elements.
• Slicing: Extract a portion of a list or tuple using slicing (my_list[start:end]).
• Length: Get the length of a list or tuple using the len() function.
• Concatenation: Combine two lists or tuples using the + operator.

Dictionaries: Key-Value Pairs for Efficient Data Management

Dictionaries are versatile data structures that store key-value pairs. They are essential for efficient data management and retrieval.

Creating a Dictionary

Dictionaries are created using curly braces ({}) or the dict() function.

student = {"name": "Alice", "age": 20, "grade": "A"}

Accessing Dictionary Values

Retrieve values from a dictionary using their corresponding keys.

name = student["name"]
print(name)

Dictionary Methods

Python offers several methods for manipulating dictionaries.

• get(): Retrieve a value by key or return a default value if the key is not found.
• keys(): Return a list of all keys in the dictionary.
• values(): Return a list of all values in the dictionary.
• items(): Return a list of key-value pairs as tuples.

File I/O: Reading and Writing Files

File I/O (Input/Output) is crucial for interacting with external files. Python provides simple and efficient ways to read and write files.

Reading a File

Use the open() function to open a file in read mode ("r").

with open("data.txt", "r") as file:
  content = file.read()

Writing to a File

Open a file in write mode ("w") to write content.

with open("output.txt", "w") as file:
  file.write("Hello, World!")

Working with CSV Files

Python's csv module simplifies working with CSV (Comma-Separated Values) files.

import csv

with open("data.csv", "r") as file:
  reader = csv.reader(file)
  for row in reader:
    print(row)

Error Handling: Gracefully Handling Exceptions

Error handling is crucial for building robust applications. Python provides exception handling mechanisms to manage errors gracefully.

Try-Except Blocks

Use try blocks to execute code that may raise exceptions. Except blocks catch and handle exceptions.

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Cannot divide by zero")

Custom Exceptions

Create custom exception classes to handle specific error conditions.

class InvalidInputError(Exception):
  pass

try:
  age = int(input("Enter your age: "))
  if age < 0:
    raise InvalidInputError("Age cannot be negative")
except InvalidInputError as e:
  print(e)

Object-Oriented Programming: Building Modular and Reusable Code

Object-Oriented Programming (OOP) is a powerful paradigm for building modular and reusable code. Python supports OOP concepts.

Classes and Objects

Classes define the structure and behavior of objects. Objects are instances of classes.

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def greet(self):
    return f"Hello, my name is {self.name}"

alice = Person("Alice", 25)
print(alice.greet())

Inheritance

Inheritance allows classes to inherit properties and methods from other classes.

class Student(Person):
  def __init__(self, name, age, grade):
    super().__init__(name, age)
    self.grade = grade

bob = Student("Bob", 20, "A")
print(bob.greet())

Polymorphism

Polymorphism enables objects of different classes to be treated uniformly.