Python Basics Tutorial: Beginners Guide With Examples

What is Python?

Python, introduced by Guido van Rossum in 1991, is a high-level programming language that emphasizes the readability of code and utilizes a concise syntax for improved understanding and accessibility. Python's user-friendly nature and cross-platform compatibility make it an ideal choice for teaching programming, fostering simplicity, and encouraging collaboration within the open-source community.

It is a programming language that is constantly being updated and has excellent support from the community. Python, renowned for its simplicity, readability, and flexibility, has garnered immense popularity among software engineers, data scientists, and developers due to its extensive collection of libraries and frameworks.

The popularity of Python has skyrocketed in recent years, as demonstrated by the data from Stack Overflow Trends. Python has emerged as the most widely used programming language, surpassing other languages in adoption and community engagement. This can be observed in the following chart:

Python has emerged as a popular choice among quality engineers for test automation due to its numerous advantages. If you want to understand why Python is widely regarded as the optimal programming language for test automation, please look at this insightful blog titled Why Python is the Go-To Choice for Test Automation. This resource offers an in-depth exploration of Python Basics' specific capabilities and strengths, making it an exceptional tool for automating tests.

By harnessing the potential of Python Basics, you can streamline your test automation endeavors, leverage its extensive range of libraries and frameworks, and tap into the vast resources and community support it offers.

Why Python?

Python's widespread adoption across diverse domains can be attributed to several compelling factors:

• User-Friendliness

  Python's syntax is straightforward and intuitive, rendering it particularly suitable for beginners. Its emphasis on simplicity diminishes the learning curve and empowers developers to write clean, understandable code.

• Versatility

  Python finds applications in web development, data analysis, artificial intelligence, machine learning, test automation, scientific computing, and more. Its extensive assortment of libraries and frameworks equips programmers with powerful tools tailored to various domains.

• Active and Thriving Community

  Python boasts a vibrant and supportive global community of developers. This community actively contributes to the language's evolution, creates new libraries, fosters knowledge sharing, and extends assistance through forums and online communities.

• Cross-Platform Compatibility

  Python runs seamlessly on multiple platforms, including Windows, macOS, and Linux, making it highly portable. Python programs can be executed on different operating systems without significant modifications.

• Rich Ecosystem of Libraries and Frameworks

  Python offers an extensive ecosystem of libraries and frameworks that expedite development processes. Popular libraries bolster productivity and provide ready-made solutions for common tasks.

This Python Basics tutorial is a handy resource for learning and quick reference. It offers a comprehensive yet concise overview of Python, making it beneficial for beginners to grasp fundamental concepts and syntax. For experienced Python programmers, it serves as a convenient tool to refresh their memory on specific topics. The Python Basics tutorial includes code snippets, examples, and explanations to demonstrate concepts effectively, making it a valuable resource for all levels of Python proficiency.

Note : Test your Python web applications on the cloud. Try LambdaTest Today

Python Basics

Within this section on Python Basics, we will delve into critical subjects, including Python installation, variable manipulation, data types, control flow statements, functions, and modules. Our approach will feature lucid explanations, code snippets, and practical examples to facilitate a comprehensive comprehension of each concept.

Installing Python

To begin your journey into the world of Python Basics, you'll need to install Python. Follow the step-by-step instructions below to complete the installation process on Windows:

• Navigate to the official Python website and access the Downloads section.
• Choose the appropriate installer for your Windows system, selecting either the 32-bit or 64-bit version based on your computer's architecture.
• Once the installer file is downloaded, install it by double-clicking on it.
• The installation wizard will appear. Ensure that you select the option to add Python to PATH, as this will allow you to easily access Python from the command line.
• Proceed with the installation by following the on-screen instructions. Python will be installed in the default directory, typically C:\Python.
• After the installation, open the command prompt by pressing the Windows key + R, typing cmd into the Run dialog, and hitting Enter.
• In the command prompt window, type the command python --version and press Enter. This will display the version of Python installed on your system, confirming a successful installation.

python --version 
      

Congratulations! You have now successfully installed Python on your Windows machine. You're ready to dive into the exciting world of Python Basics, where endless possibilities await.

If you use a different OS, you can follow the official Python documentation to install Python according to your operating system.

Please remember that the installation steps may differ slightly based on the specific version of Python and your Windows operating system. For the most up-to-date and detailed installation instructions tailored to your specific setup, it's advisable to consult the official Python documentation, as provided in the above paragraph.

Python Data Types

When working with Python Basics, understanding the different data types is essential for effective variable manipulation. Data types define how values are stored and operated upon in Python. In this section of the Python Basics tutorial, let's explore the various data types in detail.

Numbers

Numbers are used for representing numerical values in Python. The language supports several numeric data types, including integers, floating-point, and complex numbers.

Integers

Integers are whole numbers without fractional components. They can be positive or negative values. For example:

x = 13
y = -3 

Floating-Point Numbers

Floating-point numbers, or floats, are numeric values with decimal points. They can represent both fractional and real numbers. For instance:

pi = 3.14159
radius = 2.5

Floats provide more precision than integers and are commonly used in scientific computations or when working with decimal values.

Complex Numbers

Complex numbers represent quantities with real and imaginary parts. They are typically written as a + bj, where a represents the real part and b represents the imaginary part. For example:

z = 3 + 4j

Complex numbers are useful in various mathematical calculations and can be manipulated using built-in functions and operators in Python.

Strings

Strings are sequences of characters enclosed within single quotes ('') or double quotes (""). They are employed to represent textual data. Consider the following examples:

name = "Paulo Oliveira"
message = 'Hello, Paulo!'

String concatenation can be performed using the + operator:

greeting = "Hello"
name = "Paulo"
full_greeting = greeting + " " + name
print(full_greeting)  # Output: Hello Paulo

Execution result:

Booleans

Booleans serve as truth values and have two possible states: True and False. They are employed in logical operations and program flow control. Observe the following example:

is_raining = True
is_sunny = False

Boolean values often come into play within conditional statements, as we will see in future sections.

Lists

In Python, a list is a versatile and widely used data type that allows you to store and manipulate collections of items. Lists are especially valuable in test automation as they provide a convenient way to manage and organize test data, test cases, and other related information.

A list in Python is denoted by square brackets [] and can contain elements of any data type, including numbers, strings, booleans, or even other lists. Here's an example of a Python list that stores a collection of test cases:

test_cases = ["login", "register", "search", "checkout"]

In test automation, lists can be utilized in various ways. For instance, you can use lists to define a set of test data inputs, such as usernames or passwords, which must be tested across multiple scenarios. Here's an example:

usernames = ["user1", "user2", "user3"]
passwords = ["pass123", "pass456", "pass789"]

You can iterate over these lists and use the values to execute test cases with different input combinations, ensuring comprehensive test coverage.

Lists also support various operations, such as appending or removing elements, sorting, and accessing specific elements by their index. For example, you can append a new test case to an existing list using the append() method:

test_cases = ["login", "register", "search"]
test_cases.append("checkout")
print(test_cases) # Output: ['login', 'register', 'search', 'checkout']

Execution result:

You can also remove an element from the list using the remove() method:

test_cases.remove("register")
print(test_cases) # Output: ['login', 'search', 'checkout']

Execution result:

Furthermore, lists can be combined, sliced, or manipulated in other ways to perform complex operations.

Lists in Python offer a flexible and intuitive way to handle data collections in test automation scenarios. Whether it's managing test cases, test data, or result sets, the ability to store and manipulate data using lists provides a powerful tool for effective test automation.

Tuples

When learning Python Basics, a tuple is an immutable data type that allows you to store a collection of items. Tuples are particularly useful in test automation scenarios where you must represent data that should not be modified.

A tuple in Python Basics is defined using parentheses() and can contain elements of different data types. Here's an example of a tuple that stores test case data:

test_case = ("login", "user1", "pass123", True)

In test automation, tuples can be employed in various ways. One common use case is to represent test case parameters or inputs that remain constant throughout the test execution. For instance, you can define a tuple to store the login credentials for different user roles:

credentials = (
    ("admin", "admin123"),
    ("user", "user123"),
    ("guest", "guest123")
)

By using tuples, you ensure that the test case parameters remain unchanged during the test execution, maintaining the integrity and consistency of the test data.

Tuples, being immutable, offer advantages in terms of data integrity and security. Once a tuple is created, its elements cannot be modified. This property makes tuples suitable for storing sensitive or critical data in test automation, where accidental modifications should be avoided.

Tuples also support various operations, such as indexing, slicing, and unpacking. You can access specific elements in a tuple using their index:

test_case = ("login", "user1", "pass123", True)
print(test_case[0])  # Output: login

Execution result:

You can slice a tuple to extract a subset of elements:

credentials = ("admin", "user", "guest", "tester")
print(credentials[1:3])  # Output: ("user", "guest")

Execution result:

Additionally, you can unpack the elements of a tuple into separate variables:

user, password = ("admin", "admin123")
print(user)      # Output: admin
print(password)  # Output: admin123

Execution result:

Tuples provide a reliable and immutable way to represent and protect data in test automation scenarios. Whether it's storing constant test inputs, sensitive information or ensuring data integrity, tuples offer a valuable data type for effective and secure test automation.

Sets

When learning Python Basics, a set is an unordered collection of unique elements. Sets are particularly useful in test automation scenarios where you must handle a collection of distinct items or perform set operations such as unions, intersections, and differences.

A set in Python Basics is defined using curly braces {} or the set() function. Here's an example of a set that stores a collection of test tags:

test_tags = {"smoke", "regression", "functional"}

Sets in test automation can be utilized in various ways. One common use case is representing the tags or categories assigned to test cases. For instance, you can define a set to store the tags associated with a specific test case:

test_case_1_tags = {"smoke", "regression"}
test_case_2_tags = {"functional", "performance"}

You can perform set operations on sets to manipulate and compare them. Some commonly used set operations include:

Union: Combines two sets and returns a new set containing all the unique elements from both sets.

test_tags = {"smoke", "regression"}
additional_tags = {"functional", "performance"}

all_tags = test_tags.union(additional_tags)
print(all_tags)  # Output: {"regression", "functional", "smoke", "performance"}

Execution result:

Intersection: Returns a new set containing the common elements between two sets.

test_tags = {"smoke", "regression", "functional"}
selected_tags = {"functional", "performance"}

common_tags = test_tags.intersection(selected_tags)
print(common_tags)  # Output: {"functional"}

Execution result:

Difference: Returns a new set containing the elements from one set that are not present in the other set.

test_tags = {"smoke", "regression", "functional"}
excluded_tags = {"regression", "performance"}

remaining_tags = test_tags.difference(excluded_tags)
print(remaining_tags)  # Output: {"functional", "smoke"}

Execution result:

Sets also support membership tests and set operations such as subset, superset, and disjoint checks, which can be handy in test automation scenarios.

test_tags = {"smoke", "regression", "functional"}

print("regression" in test_tags)  # Output: True
print({"functional", "performance"}.issubset(test_tags))  # Output: False
print({"functional", "performance"}.isdisjoint(test_tags))  # Output: True

Execution result:

Sets provide a convenient and efficient way to handle unique elements and perform set operations in test automation. Whether it's managing test tags, performing set operations, or checking membership, sets offer a valuable data type for handling distinct items and performing set-related tasks effectively in test automation.

Dictionaries

In Python Basics, a dictionary is a versatile data type that allows you to store and retrieve key-value pairs. Dictionaries are handy in test automation scenarios where you must store and access data using unique identifiers or keys. They provide an efficient way to organize and manipulate data, making them valuable for various tasks in test automation.

To understand dictionaries, imagine a real-life dictionary where you can look up a word (key) and find its corresponding definition (value). Similarly, in Python dictionaries, you can use a key to access the associated value. Dictionaries are enclosed in curly braces {} and consist of key-value pairs separated by a colon (:).

Here are some examples of dictionaries in test automation:

Test Case Data: You can use a dictionary to store the data related to a test case, such as test inputs, expected outputs, and other relevant information. Each key represents a specific piece of data, and its corresponding value holds the actual data.

test_case_1 = {
    "name": "Login",
    "input": {"username": "testuser", "password": "password123"},
    "expected_output": "Success",
    "tags": ["smoke", "regression"]
}

Test Environment Configuration: Dictionaries can be used to store configuration settings for different test environments. Each key represents a configuration parameter, and its value stores the corresponding setting.

test_environment = {
    "url": "https://example.com",
    "browser": "Chrome",
    "timeout": 10,
    "headless": True
}

Test Data Mapping: Dictionaries can be employed to map test data to specific test cases. Each key represents a test case identifier, and its value holds the corresponding test data.

test_data = {
    "TC001": {"input": 5, "expected_output": 25},
    "TC002": {"input": 10, "expected_output": 100},
    "TC003": {"input": -2, "expected_output": 4}
}

Test Results: Dictionaries can be used to store and organize test results. Each key represents a test case identifier, and its value stores the test execution outcome.

test_results = {
    "TC001": "Pass",
    "TC002": "Fail",
    "TC003": "Pass"
}

Dictionaries provide several methods to manipulate and access data. You can retrieve values using keys, add new key-value pairs, update values, and delete entries. Here are a few examples:

#Dictionaries Access and Manipulation

test_case = {"name": "Login", "status": "Pass", "tags": ["smoke", "regression"]}
print(test_case["name"])  # Output: "Login"

test_case["status"] = "Fail"
print(test_case)  # Output: {"name": "Login", "status": "Fail", "tags": ["smoke", "regression"]}

test_case["timeout"] = 10
print(test_case)  # Output: {"name": "Login", "status": "Fail", "tags": ["smoke", "regression"], "timeout": 10}

del test_case["tags"]
print(test_case)  # Output: {"name": "Login", "status": "Fail", "timeout": 10}

Execution result:

Dictionaries provide a flexible and efficient way to organize, access, and manipulate data in test automation. Whether it's storing test case data, managing configuration settings, mapping test data, or tracking test results, dictionaries offer a powerful data structure for handling key-value pairs effectively in test automation.

Understanding and working with these data types will enable you to manipulate and process data effectively in Python. Make sure to practice and experiment with different operations to reinforce your understanding. In the next section of this tutorial on Python Basics, we will dive deeper into Python's control flow statements.

Operators

Operators play a vital role in Python programming as they allow us to perform various operations on data. In this section of this tutorial on Python Basics, we will explore three types of operators: arithmetic operators, comparison operators, and logical operators. Understanding how to use these operators will enhance your ability to perform calculations, make comparisons, and implement logical conditions in your Python Basics programs.

Arithmetic Operators

Arithmetic operators perform mathematical calculations such as addition, subtraction, multiplication, division, and more. Here are some commonly used arithmetic operators while working with Python Basics:

Addition (+): The addition operator is used to add two values together. For example:

x = 10
y = 5
result = x + y
print(result)  # Output: 15

Execution result:

Subtraction (-): The subtraction operator subtracts one value from another. For example:

x = 10
y = 5
result = x - y
print(result)  # Output: 5

Execution result:

Multiplication (*): The multiplication operator multiplies two values. For example:

x = 10
y = 5
result = x * y
print(result)  # Output: 50

Execution result:

Division (/): The division operator divides one value by another. For example:

x = 10
y = 5
result = x / y
print(result)  # Output: 2.0

Execution result:

Note: In Python 3.x, division always returns a float value. If you want to perform integer division, you can use the double-slash operator (//).

Modulus (%): The modulus operator returns the remainder of the division between two values. For example:

x = 10
y = 3
result = x % y
print(result)  # Output: 1

Execution result:

Exponentiation (**): The exponentiation operator raises the first value to the power of the second value. For example:

x = 2
y = 3
result = x ** y
print(result)  # Output: 8

Execution result:

Arithmetic operators allow you to perform mathematical operations on numeric values. They are versatile and can be used in various scenarios, such as calculating totals, averages or performing complex mathematical computations.

Comparison Operators

Comparison operators are used to compare two values and return a boolean result (True or False) based on the comparison. These operators are commonly used in conditional statements and loops. Here are the comparison operators while working with Python Basics:

Equal to (==): The equal to operator checks if two values are equal. For example:

x = 5
y = 5
result = x == y
print(result)  # Output: True

Execution result:

Not equal to (!=): The not equal to operator checks if two values are not equal. For example:

x = 5
y = 10
result = x != y
print(result)  # Output: True

Execution result:

Greater than (>): The greater than operator checks if the first value is greater than the second value. For example:

x = 10
y = 5
result = x > y
print(result)  # Output: True

Execution result:

Less than (<): The less than operator checks if the first value is less than the second value. For example:

x = 5
y = 10
result = x < y
print(result)  # Output: True

Execution result:

Greater than or equal to (>=): The greater than or equal to operator checks if the first value is greater than or equal to the second value. For example:

x = 5
y = 5
result = x >= y
print(result)  # Output: True

Execution result:

Less than or equal to (<=): The less than or equal to operator checks if the first value is less than or equal to the second value. For example:

x = 10
y = 10
result = x <= y
print(result)  # Output: True

Execution result:

Comparison operators are useful for making decisions and controlling the flow of your program based on the comparison results. They allow you to check conditions and execute specific code blocks accordingly.

Logical Operators

Logical operators combine multiple conditions and perform logical operations on them. They are typically used in conjunction with comparison operators. The three logical operators in Python are:

And: The operator returns True if both conditions on either side of the operator are True. For example:

selenium_version = 4.9
python_version = 3.11
result = (selenium_version > 4) and (python_version > 3)
print(result)  # Output: True

Execution result:

Or: The or operator returns True if either one or both of the conditions on either side of the operator are True. For example:

selenium_version = 4.9
python_version = 3.11
result = (selenium_version > 5) or (python_version < 3)
print(result)  # Output: False

Execution result:

Not: The not operator is used to negate the result of a condition. It returns True if the condition is False, and vice versa. For example:

selenium_version = 4.9
result = not(selenium_version > 5)
print(result)  # Output: True

Execution result:

Logical operators allow you to combine conditions and create complex logical expressions to control the flow of your program based on multiple conditions.

By understanding and utilizing arithmetic operators, comparison operators, and logical operators, you can perform calculations, make comparisons, and implement logical conditions in your Python programs. These operators provide the flexibility and control necessary for building robust and dynamic applications.

Control Flow Statements

Control flow statements play a crucial role in Python programming as they provide the means to control the flow of execution in your code. They empower you to make decisions, execute specific code based on conditions, and create iterative processes using loops. This section of the Python Basics tutorial will delve into two fundamental types of control flow statements: conditional statements and loops. Gaining a deep understanding of these statements will greatly enhance your ability to develop dynamic and interactive programs.

Conditional Statements

Conditional statements, also known as if-else statements, provide a way to execute different code blocks based on certain conditions. They allow you to control the flow of your program by evaluating whether a specific condition is True or False.

The basic syntax of a conditional statement in Python is as follows:

if condition:
    # code block to execute if the condition is true
else:
    # code block to execute if the condition is false

To understand conditional statements better, let's consider an example. Suppose we want to create a program that checks if a given Selenium version is updated or deprecated. We can use a conditional statement to achieve this:

selenium_version = float(input("Enter your selenium version: "))

if selenium_version >= 4:
    print("Your selenium version is updated.")
else:
    print("Your selenium version is deprecated.")

In the above code, we prompt the user to enter a number and store it in the variable selenium_version. The conditional statement then checks if the number is greater than or equal to 4. If the condition is True, it prints "Your selenium version is updated." Otherwise, it prints "Your selenium version is deprecated." This allows the program to provide the appropriate output based on the input provided.

Executing this simple code twice, first using selenium_version = 4.9, and then selenium_version = 3.9, we will get these results:

You can also expand the conditional statement to include more conditions using elif (short for else if) statements. This allows you to test multiple conditions and execute different code blocks accordingly. Here's an example:

selenium_version = float(input("Enter your selenium version: "))

if selenium_version == 4.9:
    print("Your selenium version is the latest.")
elif selenium_version >= 4:
    print("Your selenium version is updated.")
else:
    print("Your selenium version is deprecated.")

In this modified version, the program first checks if the Selenium version is equal to 4.9. If True, it prints "Your selenium version is the latest." If not, it moves to the next condition and checks if the number is greater than or equal to 4. If True, it prints "Your selenium version is updated." If both conditions are False, it executes the code block under the else statement and prints "Your selenium version is deprecated."

Executing this simple code three times, first using selenium_version = 4.9, then using selenium_version = 4, and finally with selenium_version = 3.9, we will get these results:

Loops

Loops are control flow statements that allow you to repeat a specific set of instructions multiple times. They are particularly useful when you want to perform an action iteratively or traverse through data collection.

While learning Python Basics, there are two main types of loops: FOR loops and WHILE loops.

The for loop is used when you know the number of iterations in advance or want to iterate over a sequence such as a list, tuple, or string. The basic syntax of a for loop is as follows:

for item in sequence:
    # code block to execute for each item in the sequence

To illustrate the usage of a for loop, let's consider an example where we want to print the numbers from 1 to 5:

for number in range(1, 6):
    print(number)

In this code, the range(1, 6) function generates a sequence of numbers from 1 to 5 (excluding 6). The for loop then iterates over each number in the sequence and prints it.

Executing this simple code, we will get this result:

The while loop, on the other hand, is used when you want to repeat a set of instructions as long as a certain condition is true. The basic syntax of a while loop is as follows:

while condition:
    # code block to execute while the condition is true

Let's explore an example of a while loop that calculates the factorial of a given number:

number = int(input("Enter a number: "))
factorial = 1
count = 1

while count <= number:
    factorial = factorial * count
    count += 1

print("The factorial of", number, "is", factorial)

In this code, we first prompt the user to enter a number and store it in the variable number. The variables factorial and count are initialized to 1. The while loop then multiplies the value of factorial by the value of count while the condition count <= number is true. It increments the count by 1 in each iteration. Finally, it prints the factorial of the input number.

Executing this simple code, using number = 5, we will get this result:

In the realm of Python programming, control flow statements serve as indispensable tools that grant you the ability to regulate the flow of execution within your code. Through the mastery of conditional statements and loops, you gain the power to make decisions, execute specific code blocks based on conditions, and carry out iterative actions.

These statements provide the essential elements of flexibility and control that are instrumental in constructing dynamic and interactive programs. By understanding and effectively implementing control flow statements, you unlock the potential to create sophisticated and responsive software solutions.

Functions

Functions are a fundamental concept in Python programming that allows you to organize and modularize your code. They enable you to break down complex tasks into smaller, reusable blocks of code.

In Python, you can define a function using the def keyword followed by the function name and parentheses. Here's a simple example of a function that greets the user:

#Basic function sample
def latest_selenium_version():
    print("Latest Selenium version is 4.9!")

#Calling the latest_selenium_version() function
latest_selenium_version()

When you run the above code, it will output: Latest Selenium version is 4.9! (this is the current Selenium version when writing this Python Basics tutorial). The latest_selenium_version() function is defined without arguments and performs a specific task: printing the Selenium version message. You can define functions with or without parameters based on the requirements of your code.

Arguments and Parameters

Parameters are placeholders for values that a function expects to receive, while arguments are the actual values passed to the function when calling it. Functions can have zero or more parameters, allowing you to pass values and data to the function for further processing.

Let's define a function that takes a Selenium version as a parameter and prints the message with the provided version:

def selenium_version_with_parameter(version):
    print(f"Your Selenium version is {version}!")

# Calling the selenium_version_with_parameter() function with an argument
selenium_version_with_parameter("4.9")

When you execute the above code, it will output: Your Selenium version is 4.9!. In this case, "4.9" is the argument passed to the selenium_version_with_parameter() function, and it is used as the value for the version parameter inside the function.

Return Statement

The return statement allows a function to return a value or result to the caller. It is used when you want the function to perform some computations and provide an output or result that can be utilized in the calling code.

Consider the following example of a function that calculates the total execution time of a test suite execution:

def calculate_total_execution_time(testcase_quantity, execution_time_sec):
    total_time = testcase_quantity * execution_time_sec
    return total_time

# Calling the calculate_total_execution_time() function and storing the result in a variable
result = calculate_total_execution_time(5, 35)
print("Total Execution Time in seconds:", result)

When you run the above code, it will output: Total Execution Time in seconds: 175. The calculate_total_execution_time() function takes two parameters, testcase_quantity, execution_time_sec, and computes the total execution time by multiplying them. The result is then returned using the return statement and stored in the result variable. Finally, the total execution time is printed to the console.

You can also return multiple values from a function by separating them with commas. Let's see an example of a function that calculates both the total execution time and the average time of a test suite execution:

def calculate_total_execution_time_and_average(testcase_quantity, execution_time_sec):
    total_time = testcase_quantity * execution_time_sec
    average = total_time / testcase_quantity
    return total_time, average

# Calling the calculate_total_execution_time_and_average() function and storing the results in variables
total_time_result, average_result = calculate_total_execution_time_and_average(12, 25)
print("Total Execution Time in seconds:", total_time_result)
print("Average Execution Time in seconds:", average_result)

When you execute the above code, it will output:

In this case, the calculate_total_execution_time_and_average() function returns both the total_time and average values, which are then assigned to the total_time_result and average_result variables, respectively.

Functions play a crucial role in test automation by enabling you better organize your test automation. Let's explore some examples of how functions can be used in test automation scenarios:

Logging and Reporting

In test automation, it is important to log test results and generate test reports for analysis. You can create functions to handle logging and reporting tasks, such as capturing test case execution status, logging errors, and generating comprehensive reports. By encapsulating these functionalities in functions, you can easily integrate them into your test scripts and ensure consistent reporting across multiple test cases.

Test Data Management

Test data plays a crucial role in test automation. You can create functions to handle test data management, such as fetching test data from external sources, generating random test data, or cleaning up test data after test execution. These functions can be reused across multiple test scripts, ensuring efficient and consistent data handling.

Test Case Execution Flow

In test automation, you often need to execute test cases in a specific order or handle pre-test and post-test activities. Functions can be used to define the execution flow of test cases, allowing you to set up test environments, perform necessary configurations, and handle cleanup tasks after test execution.

Reusable Test Steps

In test automation, you may encounter common test steps repeated across multiple test cases. Encapsulating these steps in functions can avoid code duplication and improve script maintainability. These functions can be called within different test cases, making it easier to update and modify the test steps when needed.

Test Assertions

Assertions are crucial in test automation to validate expected results and ensure the correctness of test outcomes. You can create functions for common assertions, such as comparing actual and expected values, checking element visibility, or verifying error messages. These assertion functions enhance code readability and simplify test script development.

These are just a few examples of how functions can be utilized in test automation. Organizing your code into functions can improve code reusability, maintainability, and readability in your test scripts.

Functions allow you to efficiently handle logging and reporting, manage test data, define test case execution flow, encapsulate reusable test steps, and perform assertions. Embracing functions in test automation empowers you to create robust and scalable test frameworks while enhancing productivity and test script maintainability.

Modules

Modules in Python are invaluable in test automation as they allow you to organize, reuse, and enhance your test scripts. In this section of this Python Basics tutorial, we will explore the concepts of importing modules, including the popular Selenium module, and creating your custom modules for test automation.

Importing Modules

Python offers a wide range of modules that can be used for test automation. One such module is Selenium, which provides a powerful framework for automating web browsers. Let's delve into the different ways to import modules in Python for test automation.

Importing a Full Module

To import the entire Selenium module, use the import keyword followed by the module name. Here's an example:

import selenium

# Now you can use the Selenium module to automate web browsers
driver = selenium.webdriver.Chrome()
driver.get("https://www.example.com")

By importing the Selenium module, you gain access to its classes and methods, enabling you to automate web browsers for testing purposes.

Importing Specific Items from a Module

If you only need specific items from the Selenium module, you can import them individually using the from keyword. This approach allows you to directly use the imported items without referencing the module name. Here's an example:

from selenium.webdriver import Chrome, Firefox

# Now you can directly use the imported browser drivers
driver = Chrome()
driver.get("https://www.example.com")

driver = Firefox()
driver.get("https://www.example.com")

In this case, we imported the Chrome and Firefox browser drivers directly from the Selenium module, allowing us to automate specific browsers without referencing the module name.

💡To use the Selenium module, you need to install it first. You can do this by using the pip command, as shown below:

pip install selenium

Running this command, Selenium will be installed in your repository, as shown below.

If you do not have pip installed on your machine, you should follow the below steps for Windows:

• Download the get-pip.py script by visiting the official pip installation page: https://pip.pypa.io/en/stable/installing/
• Save the get-pip.py file to your computer.
• Open a command prompt and navigate to the directory where you saved the get-pip.py file.
• Run the following command:

python get-pip.py

Then you can check the installation using the below command:

pip --version

Creating Custom Modules

In addition to using existing modules, you can create your custom modules to encapsulate test automation-related code and functionality. This approach helps organize your test scripts and promotes code reuse. Let's explore how to create a sample custom module for test automation.

The advantages of creating custom modules in Python for test automation include:

Enhanced Code Organization

Custom modules provide a structured approach to organizing your test automation code and functionality. They allow you to group related elements, such as functions, classes, and variables, making it easier to manage and maintain your codebase.

Increased Code Reusability

By encapsulating commonly used code or functionality within custom modules, you can promote code reuse across different test scripts. Instead of duplicating code in multiple places, you can simply import the module and leverage its functions or classes whenever needed, saving time and effort in development.

Improved Modularity and Maintainability

Custom modules promote modularity by allowing you to divide your codebase into smaller, self-contained modules. Each module can focus on a specific task or functionality, making the code more maintainable. Changes or updates can be made within a module without impacting other parts of the codebase.

Abstraction and Encapsulation

Custom modules enable you to abstract complex logic or implementation details. By exposing only the necessary functions or classes to other scripts, you can encapsulate the underlying implementation, making the module easier for other developers or testers to use and understand.

Simplified Testing and Debugging

Custom modules facilitate isolated testing and debugging of specific functionalities. By writing unit tests for each module, you can ensure that individual components of your test automation code function correctly. This targeted approach to testing and debugging increases efficiency and reduces potential issues.

Flexible Extensibility

Custom modules offer extensibility, allowing you to add new features or functionalities to your test framework. As your automation needs evolve, you can update or expand your custom modules to accommodate new requirements without disrupting the existing codebase.

Creating a Test Automation Module

To create a test automation module, you can create a new Python file with a .py extension and define functions, classes, or variables. Let's create a module named test_utils.py with some common test automation utilities:

# File: test_utils.py
def take_screenshot(driver, file_name):
    driver.save_screenshot(file_name)
    print(f"Screenshot saved as {file_name}")
def assert_element_present(driver, locator):
    try:
        driver.find_element(*locator)
        print("Element found")
        return True
    except:
        print("Element not found")
        return False

In the above code, we created two functions. The take_screenshot takes screenshots that can be used during the execution of your automated test. The second one assert_element_present asserts if an element is present on the screen.

Now, in your test script, you can import and use the functions from the test_utils module:

from selenium import webdriver
from test_utils import take_screenshot, assert_element_present

# Create a webdriver instance
driver = webdriver.Chrome()

# Use the utilities from the test_utils module
take_screenshot(driver, "homepage.png")

locator = ("id", "login_button")
assert_element_present(driver, locator)

# Close the webdriver instance
driver.quit()

By creating a custom module, we encapsulate common test automation utilities, making them reusable across different test scripts.

Modules in Python are powerful tools for test automation, allowing you to import existing modules, such as Selenium, and create your custom modules to encapsulate test automation code and utilities. By leveraging modules, you can enhance the organization, reusability, and maintainability of your test scripts, ultimately improving the efficiency and effectiveness of your test automation efforts.

Input and Output

Input and Output (I/O) operations are vital in test automation using Python Basics, particularly when working with files to populate test cases.

In this section of the Python Basics tutorial, you will learn about handling input and output in the context of test automation, focusing on standard input and output as well as file input and output.

Understanding these concepts is crucial for building dynamic and data-driven test scripts. In the further section of this Python Basics tutorial, we will explore each aspect in detail with examples related to test automation.

Standard Input and Output in Test Automation

While interacting with users through standard input may not be common in test automation, displaying output on the screen is essential for monitoring and debugging test scripts. Python's print() function is a valuable tool in this regard. Consider the following example:

# Displaying test information
test_name = "Login Test"
test_status = "Passed"
print("Test Name:", test_name)
print("Test Status:", test_status)

In this example, the test name and status are stored in variables (test_name and test_status), and the print() function is used to display this information on the screen. This allows testers to track the progress and outcome of test cases.