Python Fundamentals – Level 2: Functions, Modules & Objects

Welcome to Level 2 of the Python Fundamentals series!

In Level 1, we explored Python's basic building blocks, including strings, variables, data types, operators, conditional statements, and loops.

In this tutorial, we'll take the next step by learning how Python functions work, how to use existing functionality through modules and libraries, and how Python organizes data using objects and types.

Understanding these concepts is essential for writing reusable code, automating tasks, and eventually developing your own cybersecurity tools.

1. Python Functions

A function is a reusable block of code designed to perform a particular task.

Instead of writing the same instructions repeatedly, we can define a function once and call it whenever we need it.

Python functionality can come from three main sources:

1. Built-in functions

These are functions included directly in Python. They are available without installing additional packages or importing a module.

Examples include:

print() – Displays information.
input() – Receives user input.
len() – Returns the length of an object.
type() – Identifies an object's type.
int() – Converts a value into an integer.
str() – Converts a value into a string.
max() – Returns the largest value.
min() – Returns the smallest value.
sum() – Calculates the sum of values.

Example:

numbers = [10, 20, 30, 40]

print(len(numbers))
print(max(numbers))
print(min(numbers))
print(sum(numbers))

Output:

These functions are immediately available because they are part of Python's built-in functionality.

2. Standard library

Python comes with a collection of additional modules known as the standard library.

These modules provide functionality for common tasks, such as mathematical calculations, statistics, file handling, operating system interaction, and time-related operations.

Unlike built-in functions, you generally need to import the relevant module before using its functionality.

Examples include:

math – Mathematical operations.
statistics – Statistical calculations.
os – Operating system interaction.
time – Time-related functions.
random – Generating random values.

3. Third-party packages

Third-party packages are developed outside Python's standard library.

They provide additional functionality that can be installed and used in your projects.

Examples include:

requests – Working with HTTP requests.
numpy – Numerical computing.
pandas – Data analysis.
scapy – Network packet manipulation.
beautifulsoup4 – Parsing HTML and XML.

Third-party packages are commonly installed using Python's package installer, pip.

Example:

pip install requests

After installation, you can import the package into your Python program.

import requests

Many machine learning and artificial intelligence tools are also distributed as third-party packages.

2. Built-in Functions

Built-in functions are among the most frequently used features in Python.

They allow us to perform common operations without implementing everything ourselves.

Let's explore some useful examples.

2.1 The len() Function

The len() function returns the number of items in an object.

message = "Hello Python"

print(len(message))

Output:

In this example, Python counts every character, including the space.

The function also works with other data structures, such as lists and tuples.

2.2 The type() Function

The type() function returns the type of an object.

name = "Roger"
age = 26
height = 181.5

print(type(name))
print(type(age))
print(type(height))

Output:

<class 'str'>
<class 'int'>
<class 'float'>

This is useful when checking the data type of a variable.

2.3 The max() and min() Functions

These functions return the largest and smallest values in a collection.

numbers = [15, 42, 8, 29, 3]

print(max(numbers))
print(min(numbers))

Output:

42
3

2.4 The sum() Function

The sum() function calculates the total of numeric values.

numbers = [10, 20, 30, 40]

total = sum(numbers)

print(total)

Output:

There are many more built-in functions available. You can explore the complete list in the official Python documentation.

3. Standard Library

The Python standard library provides additional functionality through modules.

A module is imported before its functionality can be accessed.

The general syntax is:

import module_name

After importing a module, you can access its functions and other members using dot notation.

3.1 The math Module

The math module provides mathematical functions and constants.

import math

print(math.sqrt(25))
print(math.pi)

Output:

5.0
3.141592653589793

Let's break this down:

import math imports the module.
math.sqrt(25) calculates the square root of 25.
math.pi accesses the mathematical constant pi.

Notice how we use math. before accessing its functionality.

3.2 The statistics Module

The statistics module provides functions for statistical calculations.

import statistics

numbers = [10, 20, 30, 40, 50]

print(statistics.mean(numbers))
print(statistics.median(numbers))

Output:

30
30

Here:

statistics.mean() calculates the average.
statistics.median() returns the middle value of the dataset.

3.3 The random Module

The random module allows us to generate random values.

import random

number = random.randint(1, 10)

print(number)

Possible output:

The result can be any integer between 1 and 10, inclusive.

Important security note: The standard random module is not designed for security-sensitive randomness. For passwords, authentication tokens, and cryptographic keys, Python provides the secrets module instead.

Example:

import secrets

token = secrets.token_hex(16)

print(token)

This generates a cryptographically secure random hexadecimal token.

4. Modules and Libraries in Python

Python uses modules and libraries to organize code and make functionality reusable.

Module

A module is a single Python file containing code, such as functions, classes, and variables.

For example:

math
random
statistics

These are standard library modules.

You can also create your own module by creating a Python file.

Library

A library is a collection of reusable functionality that helps developers perform specific tasks.

The term is used broadly in Python and can refer to a collection of modules or packages.

Package

A package is a way of organizing related Python modules, generally using a directory structure.

For example, a project might look like this:

my_project/
│
├── main.py
│
└── utilities/
    ├── __init__.py
    ├── network.py
    └── files.py

Here, utilities is a package containing two modules: network.py and files.py.

Importing Modules

There are different ways to import functionality.

Import an entire module:

import math

print(math.sqrt(16))

Import a specific function:

from math import sqrt

print(sqrt(16))

Import a module using an alias:

import statistics as stats

numbers = [10, 20, 30]

print(stats.mean(numbers))

Aliases allow us to use shorter names when referencing modules.

5. Defining a Function

So far, we've been using functions that Python or external packages already provide.

However, Python also allows us to create our own functions.

We define a function using the def keyword.

The general syntax is:

def function_name():
    # Code to execute

Let's create a simple function:

def greet():
    print("Hello there!")

greet()

Output:

Hello there!

Let's understand what happened:

def tells Python that we are defining a function.
greet is the function's name.
Parentheses () contain the function's parameters, if any.
The indented code is the function body.
greet() calls the function and executes its instructions.

Defining a function does not automatically execute it. We must call it.

5.1 Functions with Parameters

Functions can receive information through parameters.

A parameter is a variable specified in the function definition.

def greet(name):
    print("Hello", name)

greet("Roger")
greet("Ana")

Output:

Hello Roger
Hello Ana

In this example:

name is the parameter.
"Roger" and "Ana" are arguments passed when calling the function.

Parameters allow functions to work with different values without rewriting the same code.

5.2 Functions with Multiple Parameters

A function can accept more than one parameter.

def add(a, b):
    result = a + b
    print(result)

add(10, 5)
add(20, 30)

Output:

15
50

The values are passed into the function and used to perform the calculation.

5.3 The return Statement

The return statement allows a function to send a result back to the part of the program that called it.

def add(a, b):
    return a + b

result = add(10, 5)

print(result)

Output:

There is an important difference between print() and return:

print() displays information on the screen.
return sends a value back to the caller so it can be stored or used elsewhere.

For reusable functions, returning a result is often more useful than simply printing it.

5.4 Default Parameters

Python allows us to specify default values for parameters.

def greet(name="Guest"):
    print(f"Welcome, {name}!")

greet()
greet("Roger")

Output:

Welcome, Guest!
Welcome, Roger!

When no argument is provided, Python uses the default value.

6. Objects and Types

One of the most important concepts in Python is that everything is an object.

Strings, integers, floating-point numbers, lists, dictionaries, and even functions are objects.

Every object has a type that determines what kind of data it represents and what operations can be performed on it.

For example:

name = "Python"
age = 26
price = 19.99
is_active = True

print(type(name))
print(type(age))
print(type(price))
print(type(is_active))

Output:

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

The type() function allows us to inspect the type of an object.

6.1 Understanding Objects

Consider this example:

message = "Hello Python"

Here, message refers to a string object.

The object contains the string value and supports operations specific to strings.

For example, we can convert it to uppercase:

print(message.upper())

Output:

HELLO PYTHON

This introduces another important Python concept: methods.

7. Methods and Attributes

Functions, methods, and attributes are related concepts, but they are not the same.

7.1 Methods

A method is a function associated with an object or a class.

Methods are commonly called using dot notation.

The general syntax is:

object.method()

For example:

message = "hello python"

print(message.upper())
print(message.lower())
print(message.capitalize())

Output:

HELLO PYTHON
hello python
Hello python

Here:

upper() converts the string to uppercase.
lower() converts the string to lowercase.
capitalize() capitalizes the first character.

These methods belong to Python's string type.

Another example using lists:

tools = ["Nmap", "Wireshark"]

tools.append("Burp Suite")

print(tools)

Output:

['Nmap', 'Wireshark', 'Burp Suite']

The append() method adds a new item to the end of a list.

7.2 Attributes

An attribute is a value associated with an object.

You can access an attribute using dot notation.

The general syntax is:

object.attribute

Let's create our own class to understand this better.

class Student:

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

student = Student("Roger", 26)

print(student.name)
print(student.age)

Output:

Roger
26

Let's break it down:

class Student defines a new class.
__init__() is a special method called when a new object is created.
self refers to the current object.
self.name and self.age are attributes.
student is an object created from the Student class.

We can also define methods inside our class:

class Student:

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

    def introduce(self):
        print(f"My name is {self.name} and I am {self.age} years old.")

student = Student("Roger", 26)

student.introduce()

Output:

My name is Roger and I am 26 years old.

Notice the difference:

student.name accesses an attribute.
student.introduce() calls a method.

Both use dot notation, but they serve different purposes.

8. Practical Exercises

It's time to put these concepts into practice!

Try solving the following exercises without looking at the solutions.

Exercise 1 – Built-in Functions

Create a list containing five numbers. Use len(), max(), min(), and sum() to display information about the list.

Exercise 2 – Standard Library

Import the math module and write a program that calculates the square root of a number entered by the user.

Exercise 3 – Random Numbers

Use the random module to generate a random integer between 1 and 100.

Exercise 4 – Creating Functions

Create a function called welcome() that displays a welcome message.

Exercise 5 – Function Parameters

Create a function that accepts two numbers and prints their multiplication result.

Exercise 6 – Return Values

Create a function that accepts a temperature in Celsius and returns its equivalent in Fahrenheit.

Formula:

Fahrenheit = (Celsius × 9/5) + 32

Exercise 7 – Modules

Create a separate Python file called calculator.py containing a function that adds two numbers.

Import that function into another Python file and use it.

Exercise 8 – Methods

Create a string containing your name. Use at least three string methods to manipulate it.

Exercise 9 – Attributes

Create a Computer class with attributes for brand, model, and RAM. Create an object and display its attributes.

Exercise 10 – Mini Project: Security Information Tool

Build a simple program that:

Defines a function called display_info().
Accepts a username and an IP address as parameters.
Displays both values using an f-string.
Uses a second function to validate whether the IP address follows a basic IPv4 format.

Hint: Python's ipaddress standard library module can help you validate IP addresses.

9. Conclusion

Congratulations! You've completed Level 2 of the Python Fundamentals series.

In this tutorial, we explored how Python organizes and reuses functionality.

You have learned about:

Built-in Python functions.
The Python standard library.
Third-party packages and pip.
Modules, libraries, and packages.
Defining and calling your own functions.
Parameters, arguments, and return values.
Objects and data types.
Methods and attributes.
Creating basic classes and objects.

Understanding these concepts will make it much easier to build structured Python programs instead of writing everything in one large script.

Applying Python to Cybersecurity

These concepts are particularly useful when developing security tools.

For example, functions allow us to reuse scanning logic, modules provide access to networking capabilities, third-party packages extend our capabilities, and objects help us organize more complex applications.

As we progress through the series, we'll gradually apply these fundamentals to practical cybersecurity tasks, including network automation, reconnaissance, and security analysis.

Keep learning. Keep building. Keep experimenting.

Search This Blog

The Purple Team Journey by Ozz961