Ultimate Web API Development with Django REST Framework: Build Robust and Secure Web APIs with Django REST Framework Using Test-Driven Development for Data Analysis and Management (English Edition)

CHAPTER 1

Django REST and TDD Essentials

Introduction

This chapter introduces key concepts for modern API development with Python and Django Rest Framework. You will learn the principles of HTTP and the basics of Django Rest Framework. We will explore the dynamic and strongly typed nature of Python, how to handle web requests with HTTP, and Django’s batteries-included approach for building web applications. By showing you the importance of Test-Driven Development (TDD) and version control with Git, we will guide you through developing robust and maintainable code. Additionally, we will touch on Python’s standard library and Django’s project setup. This chapter sets the stage for understanding essential web development concepts and practices.

Structure

In this chapter, we will discuss the following topics:

Introduction to Python

What is HTTP?

Introduction to Django

TDD Concepts and Workflow in Django

Building Basic Models in Django

Writing Tests Using Pytests

Introduction to Git

Project Introduction

Introduction to Python

Python is a high-level interpreted programming language. Due to its high level, it allows the development of complex applications with fewer lines of code compared to many other languages.

Unlike many languages that use semicolons or braces to mark the end of a statement, Python relies on newlines and tabulations.

# Initialize counter

count = 1

# Loop from 1 to 10

while count <= 10:

# Check if the number is even

if count % 2 == 0:

print(f{count} is even)

else:

print(f{count} is odd)

# Increment the counter

count += 1

The provided code demonstrates a loop that executes as long as the variable count remains less than or equal to 10. Within the loop, we check if the count is even by using the modulus operator %. If the count is divisible by 2 (count % 2 == 0), it prints that the number is even. Otherwise, it prints that x is odd. After each iteration, x is incremented by 1 with x += 1.

Indentation can be seen in the loop when everything runs at the same level. The same applies to the conditionals if and else. The code inside the while will be executed until the condition is false.

Python is a strongly typed language, enforcing strict type constraints without implicit conversion between types. It is dynamically typed, meaning it determines variable types at runtime instead of statically typed languages that perform type checking at compile time. Let us see what strongly typed and dynamically typed means with examples:

def add(a, b):

return a + b

# Calling add with integers

result1 = add(5, 7)

print(result1)  # Output: 12

# Calling add with strings

result2 = add(Hello, , World!)

print(result2)  # Output: Hello, World!

# Attempting to add incompatible types

result3 = add(Number: , 5)

print(result3)  # This will raise a TypeError at runtime

In the preceding code, the function add uses the binary operator + against the parameters a and b. When we call the function add with parameters of the same type, the function will return the result of the operation. However, a TypeError will be raised at runtime when the types differ. Type compatibility is only checked at runtime.

Being strongly typed means it fails on implicit type conversions. Let us see an example to understand what it means:

a = 10  # Integer type

b = 5  # String type

# Attempting an arithmetic operation between an integer and a string

result = a + b

In this code snippet, we attempt to add an integer (a) to a string (b). Because Python is a strongly typed language, it does not implicitly convert the string b into an integer to perform the addition. Consequently, this code will raise a TypeError at runtime, indicating that you cannot directly add an int (integer) and str (string) due to their incompatible types.

The categorization of programming languages is often based on their typing discipline (static versus dynamic) and type strength (strong versus weak). The following table outlines how various programming languages fall into these categories:

Table 1.1: Categorization of programming languages based on two different typing characteristics

Understanding Variables as References

Python differs from other programming languages; it doesn’t need to declare variable types beforehand. In Python, variables act as pointers to objects, not the objects themselves.

To understand how it works, check this simple Python code:

x=5

y=x  # At this point, x and y point to the same object 5.

x=10 # Now, x points to a different object, 10, but y points to 5.

F-Strings

The Python Enhancement Proposal (PEP) 498 (https://peps.python.org/pep-0498/) proposed adding f-strings to the Python language and it was introduced in Python 3.6. F-string is a way to include the value of Python expressions inside string literals. F-strings are denoted by an f or F prefix before the opening quotation mark of a string literal.

name = Pepe

age = 23

message = fHello, {name}. You are {age} years old.

print(message)

The output will be:

>>> Hello, Pepe. You are 23 years old.

F-string also supports formatting options when using the curly braces:

number = 3.13

formatted_number = f{number:08.2f}

print(formatted_number)

The preceding f-string specifies options after the colon :. The 08 specifies that the string should be at least eight characters and the .2f dictates that the number will be formatted with two decimal places. The string will be padded with zeros:

>>> 00003.13

There are plenty of options when using the f-string. Make sure to check Python documentation at: https://docs.python.org/3/library/string.html#formatspec

Data Structures

Python has a rich set of built-in data structures, allowing you to store and access data. Any Python programmer needs to know and understand these data structures.

Tuple

A tuple in Python is an ordered collection of immutable objects of fixed sizes. Once a tuple is created, changing its size is impossible and does not support item assignment.

# Let's create a new tuple

tuple_1 = (1,2,3)

# Access the element at position 0

tuple_1[0]

>> 1

Lists

A list is an ordered collection of objects that does not have a fixed length, and it supports item assignment.

# Let's create a new list

example = [1,2,3]

# Access the element at position 0

example[0]

>>> 1

# change the element in position 0

example[0] = -1

# You can iterate through a list

for index, element in enumerate(example):

print(felement {element} at index {index})

The form iterates through the elements of the list. Enumerate is a Python built-in function that adds a counter to an iterable and returns it as an enumerate object.

Set

A Set is an unordered collection of unique objects with no fixed size. Since it is unordered, it is not subscriptable.

# Let's create a new set

example = {1,2,3}

# print the size of the set

print(len(example))

>>> 3

# We can check if an element exists using the in-operator

1 in example

>>> True

# if we add an existing element, its size does not change

example.add(1)

len(example)

>>> 3

# We can do a set difference

example - {1}

>>> {2, 3}

# or intersection

example.intersection({1})

>>> {1}

Dictionary

Dictionaries are key-value stores that are indexed by keys and are unordered. In Python, it is widespread to work frequently with dictionaries.

# Let's create a dictionary

example = {key_1: 1, key_2: value }

# It is possible to access the value using a valid key

example[key_1]

>>> 1

# The get operator gets the key or the default value

example.get(key_3, None)

>>> None

# It is possible to iterate a dictionary

for key, value in example.items():

print(fkey {key} value {value})

Functions

Python uses indentation to define blocks of code:

def hello_world(name: str, greeting=Hello) -> None:

print(f{greeting} world! {name})

for i in range(1, 100):

print(i)

Functions are defined with a def keyword, and support positional and keyword arguments, as shown in the function hello_world.

In programming, there are two ways to pass arguments to a function when it is called: pass by reference or pass by value. When a function argument is passed by reference, the function receives a reference to the original variable rather than a copy of its value.

Pass by copy (value) means a function receives a copy of the argument’s value. Changes to this copy do not affect the original variable.

Python employs a mechanism often described as ‘pass-by-object-reference’ or ‘pass-by-assignment’. The function receives a reference to the object and is not copied. How the function interacts with the passed object depends on whether the object is mutable or immutable.

Let us see an example with immutable objects:

from typing import Any

def modify(x: Any) -> Any:

x = x + 1

return x

a = 5

print(modify(a))  # Prints: 6

print(a)       # Prints: 5, showing 'a' is unchanged outside the function

Numbers, strings, and tuples are examples of immutable objects. When you pass an immutable object to a function and that function attempts to modify it, a new object is created and assigned within the function’s local scope.

With mutable objects, the behavior is different, and the object is changed, producing a side effect:

def modify(lst: list) -> None:

lst.append(4)  # Modifies the list in-place

my_list = [1, 2, 3]

modify(my_list)

print(my_list)  # Prints: [1, 2, 3, 4], showing 'my_list' was modified by the function

As a good practice, you should avoid side effects and your functions should not modify the mutable objects passed as arguments.

Classes and Objects

A class in Python is a blueprint for instantiating objects, which has a set of attributes and methods. An object is an instance of a class. Each object can share a common behavior through methods defined in the class.

class SpruceMoose:

def __init__(self, name):

self.name = name

def quack(self):

print(Quack!)

class Duck:

def quack(self):

print(Quack Quack!)

In the preceding code, we can see two Python classes. The SpruceMoose has two methods implemented: the __init__ and the quack. Methods with double underscore are known as dunder or magic methods. Dunder methods allow your classes to implement and interact with built-in Python operations. They allow you to define how your objects should behave in various contexts, such as when they are being added together, represented as strings, or compared.

# Creating instances of the classes

moose = SpruceMoose(Spruce)

duck = Duck()

# Calling the quack method on each instance

moose.quack()  # This will print Quack!

duck.quack()   # This will print Quack Quack!

The code prints the Quack! and Quack Quack! respectively.

Error Handling

An exception is an unexpected event that disrupts the normal flow of a program. When an exception occurs, Python creates an Exception object that will propagate up the call stack. Handling exceptions is crucial for writing robust code that can deal with unexpected errors gracefully. Python uses a try-except block to catch exceptions. Let us see an example when Python code tries to access a key that does not exist in a dictionary:

def main():

traffic_light = {red: 2, green: 0, yellow: 1}

traffic_light[blue]

main()

print(finish)

Traceback (most recent call last):

File , line 1, in

File , line 3, in main

KeyError: 'blue'

If we want our program to print finish, we need to handle the KeyError exception properly:

>>> try:

…  main()

… except KeyError as ex:

…  print(fKey {ex} does not exists)

… print(finish)

>>> Key 'blue' does not exist

>>> finish

The new code with the try-except catches the exception and prints that the blue key does not exist. Finally, it prints finish. There are situations when the function body we call is more complex and could return another type of exception. In this case, our try-except will only catch the KeyError. In this situation, it is tempting for developers to catch the generic exception, and by doing this, it will catch all possible exceptions. It is a good practice to catch specific exceptions, not generic ones since it could catch unexpected errors and obscure the program’s logic.

Python try-except also supports else and finally clauses. Let us see an example:

def divide_function(n: int) -> None:

try:

result = 0 / n

except ZeroDivisionError:

print(Divided by zero.)

else:

print(Division successful.)

finally:

print(Always printed.)

The divide_function accepts an integer "n, which is used as a divisor in the division. Then n equals zero, it will print Divided by zero. and Always printed.. When n is not equal to zero, it will print Division successful. and Always printed.". The else branch is only executed when there is no exception and the finally is always executed. Usually, the final branch is used to clean up resources or close connections.

Duck Typing

Duck typing is a term used in dynamic languages that do not have robust type systems. The idea comes from the phrase, If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck. Since our two classes implement the quack method, instances of both SpruceMoose and Duck fulfill an interface and allow objects to be interchanged regardless of their type.

Polymorphism

Polymorphism is the ability of different objects to respond to the same method call. Duck typing can be seen as a polymorphism, where an object’s compatibility is determined at runtime by the methods it implements, not by its inheritance hierarchy.

Python supports multiple class inheritance, allowing polymorphism.

class Airplane:

def __init__(self, name):

self.name = name

def horn(self):

raise Exception(Airplanes do not need a horn!)

class SpruceMoose(Airplane):

def horn(self):

print(Honk Beep hoonk!)

The preceding code shows an example of class inheritance. The horn method is overridden in the SpriceMoose class.

Generators

Simple Generators were introduced in the PEP255 (https://peps.python.org/pep-0255/). The PEP was accepted and introduced in Python 2.2. Generators simplify the creation of iterators. The PEP255 also introduced the yield statement to Python, which allows the suspension and resumption of the execution of a function. Generators are defined as a function, but instead of returning a value with a return, it yields a sequence of values using the yield.

from typing import Generator

def fibonacci() -> Generator[int, None, None]:

current, next_value = 0, 1

while True:

yield current

current, next_value = next_value, current + next_value

The fibonacci function generates an infinite sequence of Fibonacci numbers using a generator. It efficiently produces values on-demand without precomputing or storing the entire sequence by continuously yielding the following number. This approach showcases the power and efficiency of Python’s generators for handling infinite sequences in a resource-friendly manner.

Here is an example of how to use the fibonacci to generate the first 10 numbers:

for index, fib_number in enumerate(fibonacci()):

print(fib_number)

if index > 10:

break

The preceding code iterates the Fibonacci numbers using the enumerate. Enumerate is a built-in Python function that adds a counter to an iterable, enabling you to loop over something and have an automatic counter. The loop body prints the Fibonacci number and checks if the index is more than 10. When it is bigger, it stops the iteration; otherwise, it will loop indefinitely.

Like list comprehensions, generator expressions allow you to create generators concisely and straightforwardly. They look a lot like list comprehensions but use parentheses instead of square brackets:

squares = (x*x for x in range(10))

The generator above computes the square of each number from 0 to 9.

Later in the Pytest section, we will see that understanding generators is critical in creating test fixtures.

Decorators

Decorators were introduced by PEP318 (https://peps.python.org/pep-0318/) and have been available since Python 2.4. Decorators allow the modification of functions and methods using other functions. They are denoted by the @ symbol and placed above a function definition. Decorators make the code clean, enabling code reuse.

def log_args(func):

def wrapper(*args, **kwargs):

print(fArguments were: {args}, {kwargs})

return func(*args, **kwargs)

return wrapper

The log_args decorator logs the arguments of a function. The wrapper function captures the decorated function’s arguments (*args for positional and **kwargs for keyword arguments) and prints them before calling the original function with those arguments. This pattern allows developers to inject logging or other pre- and post-invocation behavior into any function, improving debugging and monitoring without altering the original function’s code.

Here is an example of how