Back

/ 10 min read

Python Refresher: Revisiting the Fundamentals

Python3 Img

Python is a versatile and beginner-friendly programming language used in various fields, including web development, data analysis, machine learning, and more. Whether you’re a seasoned Python developer or just getting started, it’s essential to review and reinforce your knowledge of Python’s fundamental concepts. In this Python refresher, we’ll revisit some of these key concepts to help you strengthen your Python programming skills.

Variables and Data Types

Python is a dynamically typed language, which means you don’t need to explicitly declare variable types. Here are some of the most common data types in Python, along with code examples:

Boolean Values (bool)

Boolean values represent true or false. They are often used in conditional statements and logical operations. Examples include True and False.

# Boolean examples
is_true = True
is_false = False

Integers (int)

Integers represent whole numbers without any decimal point. Examples include -1, 0, and 42.

# Integer examples
positive_integer = 10
negative_integer = -5
zero = 0

Floating-point Numbers (float)

Floating-point numbers represent numbers with decimal points or fractions. Examples include 3.14, 0.01, and -0.5.

# Float examples
pi = 3.14
small_fraction = 0.01
negative_float = -0.5

Srtrings (str)

Strings represent text and are enclosed in single or double quotation marks. Examples include "Hello, World!", 'Python', and "123".

# String examples
greeting = "Hello, World!"
programming_language = 'Python'
numeric_string = "123"

Lists (list)

Lists are ordered collections of items. They can contain elements of different data types and are defined using square brackets []. Examples include [1, 2, 3], ["apple", "banana", "cherry"], and [1, "two", 3.0].

# List examples
numbers = [1, 2, 3]
fruits = ["apple", "banana", "cherry"]
mixed_list = [1, "two", 3.0]

Dictionaries (dict)

Dictionaries are collections of key-value pairs. Each key is associated with a value, and they are defined using curly braces {}. Examples include {"name": "Alice", "age": 25}, {"city": "New York", "population": 8.4 million}, and {} (an empty dictionary).

# Dictionary examples
person = {"name": "Alice", "age": 25}
city_info = {"city": "New York", "population": 8.4 million}
empty_dict = {}

Control Structures

Python offers control structures for decision-making and repetition. These control structures allow you to manage the flow of your program and perform actions based on conditions or repeatedly execute code. Let’s explore some of the key control structures in Python:

If Statements

Conditional statements, often referred to as “if statements,” are used to make decisions in your code. They allow you to execute specific blocks of code based on whether a condition is true or false.

if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

In this example, if the age is greater than or equal to 18, it prints “You are an adult”; otherwise, it prints “You are a minor.”

While Loops

The while loop is used for repetitive tasks. It repeatedly executes a block of code as long as a condition is true. Be cautious to avoid infinite loops by ensuring that the condition eventually becomes false.

# This code snippet prints the numbers from 1 to 5 using a while loop.
i = 1
while i <= 5:
    print(i)
    i += 1

For Loops (for-in)

The for loop, often used with the in keyword, is used for iterating over a sequence (such as a list or string). It simplifies iteration and is commonly used in Python.

# Iterate through the fruits list and prints each fruit.
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

Break and Continue Statements

Python provides two special statements within loops: break and continue.

  • The break statement is used to exit a loop prematurely. It terminates the loop’s execution based on a condition.
  • The continue statement is used to skip the current iteration of a loop and move to the next one.

These statements are handy for controlling loop behavior and responding to specific conditions.

# Exit the loop when i is equal to 5, preventing further iterations.
for i in range(1, 11):
    if i == 5:
        break
    print(i)

Functions

Functions in Python allow you to encapsulate and reuse code. You can define functions using the def keyword.

def greet(name):
    return f"Hello, {name}!"


result = greet("Prajwal")
print(result)  # Output: "Hello, Prajwal!"

Classes and Objects

Classes in Python are blueprints for creating objects, while objects are instances of classes. They allow you to model real-world entities in your code.

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


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


alice = Person("Reader", 25)
print(alice.greet())  # Output: "Hello, Reader!"

In this example, we define a class called Person with attributes name and age. The __init__ method is a special method called when an object is created, and the greet method returns a personalized greeting for the person.

We then create an instance of the Person class named alice with the name "Prajwal" and age 25. Finally, we call the greet method for the alice object to print a greeting message.

Modules

A module is a single Python file containing variables, functions, and classes. Modules are used to encapsulate related code and promote code reusability. You can import modules using the import keyword.

# Importing a module
import math


# Importing a function from a module
from math import sqrt


# Importing a module and giving it an alias
import math as m


# Importing all functions from a module
from math import *

Packages

In Python, packages are a way to organize and structure your code into directories and modules. They allow you to group related modules together, making it easier to manage and maintain large codebases. Packages are essential for organizing complex projects and preventing naming conflicts between modules.

# Importing a module from a package
from package_name import module_name

An example to understand clear distinction b/w packages and modules is as follows:

geometry_project/
    shapes/               # Package
        __init__.py       # Required for package recognition
        circles.py        # Module
        squares.py        # Module
    utils/                # Another Package
        __init__.py       # Required for package recognition
        math_operations.py # Module

In this structure:

  • geometry_project is the root directory of your project.
  • shapes and utils are packages.
  • circles.py, squares.py, and math_operations.py are modules.

To import a module from a package, you use dot notation. For example:

from geometry_project.shapes import circles
from geometry_project.utils import math_operations

Exceptions

Exceptions are events that occur during program execution when something unexpected or erroneous happens. These exceptions can disrupt the normal flow of your code, and handling them appropriately is essential to ensure your program remains robust and responsive.

The Try-Except Block

The try-except block is used to catch and handle exceptions in Python. Here’s the basic structure:

try:
    # Code that may raise an exception
except ExceptionName:
    # Code to handle the exception

Let’s break down how the try-except block works:

  • The try block contains the code that you suspect might raise an exception.
  • If an exception occurs within the try block, Python immediately jumps to the corresponding except block.
  • In the except block, you specify the type of exception you want to catch (e.g., ExceptionName). This is optional, and you can use a generic except clause to catch any exception.
  • Within the except block, you can write code to handle the exception, which might include logging an error message, recovering from the error, or taking other appropriate actions.

Let’s consider an example where we attempt to divide a number by zero, which would raise a ZeroDivisionError exception:

try:
    result = 10 / 0  # Attempting to divide by zero
except ZeroDivisionError:
    print("Division by zero is not allowed.")

In this example, the try block attempts to perform a division operation that can result in a ZeroDivisionError. When the exception occurs, Python immediately transfers control to the except block, where we print an error message.

# Handling multiple exceptions
try:
    # Code that may raise an exception
except ExceptionType1:
    # Code to handle ExceptionType1
except ExceptionType2:
    # Code to handle ExceptionType2

File I/O

In Python, you can read from and write to files using the open() function. This functionality is crucial for handling data persistence and interacting with external files.

Reading a File

To read the contents of a file, you can use the open() function with the mode "r" (read mode). Here’s how you can read a file:

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

Writing to a File

To write data to a file, you can use the open() function with the mode "w" (write mode). Here’s how you can write to a file:

# Writing to a file
with open("file.txt", "w") as f:
    f.write("Hello, world!")

Additional File Modes

In addition to "r" (read) and "w" (write) modes, there are other modes you can use with the open() function, such as "a" (append) for appending data to a file without truncating it and "b" for binary mode when dealing with non-text files.

Lambda Functions

Lambda functions, also known as anonymous functions, are a concise way to define small, one-time-use functions in Python. They are defined in a single line using the lambda keyword.

lambda arguments: expression

Here’s how you can define and use a lambda function:

# Defining a lambda function
add = lambda x, y: x + y


# Using a lambda function
result = add(2, 3)
print(result)  # Output: 5

In this example:

  • We define a lambda function called add that takes two arguments x and y and returns their sum.
  • We then use the lambda function by calling add(2, 3), which returns 5.

Lambda functions are commonly used in functional programming and with functions like map(), filter(), and sorted().

Generators

Generators in Python are a powerful way to create iterable sequences of items. Unlike lists or other data structures, generators create values on-the-fly as you iterate over them. This can be incredibly efficient, especially for large datasets or infinite sequences.

Defining a Generator

Generators are defined using functions, just like regular functions, but instead of using the return keyword, they use the yield keyword. The yield statement is used to produce a value from the generator function while preserving the function’s state for the next iteration.

Here’s an example of a simple generator function:

# Defining a generator
def countdown(n):
    while n > 0:
        yield n
        n -= 1

In this example, the countdown generator yields a sequence of numbers from n down to 1.

Using a Generator

Once you’ve defined a generator, you can use it to iterate over the generated values. You typically create a generator object by calling the generator function with the desired parameters.

# Using a generator
countdown_generator = countdown(5)

You can retrieve values from the generator using the next() function, as shown here:

print(next(countdown_generator))  # Output: 5

You can also iterate over the generator using a for loop, which will continue until the generator is exhausted:

for i in countdown_generator:
    print(i)  # Output: 4, 3, 2, 1

Generators are memory-efficient and are especially useful when dealing with large datasets or when you want to create sequences dynamically. They allow you to work with data one item at a time, rather than loading everything into memory at once.

Decorators

Decorators in Python are a powerful way to modify the behavior of functions or methods without changing their code. They are often used to add functionality or behavior to functions dynamically.

Defining a Decorator

A decorator is itself a function that takes another function as an argument and returns a new function that usually extends or enhances the behavior of the original function. Decorators are typically defined using the @ symbol followed by the decorator function’s name.

Here’s an example of defining a simple decorator called uppercase:

# Defining a decorator
def uppercase(func):
    def wrapper():
        result = func()
        return result.upper()
    return wrapper

In this example, the uppercase decorator takes a function func as an argument, and it defines an inner function wrapper that modifies the result of func by converting it to uppercase.

Using a Decorator

Once a decorator is defined, you can use it to modify the behavior of other functions. You apply a decorator to a function using the @ symbol, followed by the decorator’s name, just before the function definition:

# Using a decorator
@uppercase
def greet():
    return "Hello, world!"

In this example, the @uppercase decorator is applied to the greet function. When you call greet(), it will actually invoke the wrapper function created by the decorator, which will modify the result to be in uppercase.

Decorators are a powerful tool in Python for extending and customizing the behavior of functions, making your code more modular, reusable, and maintainable. They are widely used in libraries and frameworks to add functionality to classes and methods.