Python: Knowledge Essentials Everyone Should Have

SOLID

SOLID is a mnemonic describing five basic principles of object-oriented design:

• S - Single Responsibility Principle: A class should have only one reason to change, meaning it should be responsible for a single specific functionality. This helps us avoid overly large and complex classes, making code management easier.

• O - Open/Closed Principle: A class should be open for extension but closed for modification. Changes to the class should be made by adding new code, not by changing existing code.

• L - Liskov Substitution Principle: Objects of a certain class should be replaceable by objects of their subclasses without changing the program's behavior. This helps maintain code consistency and flexibility.

• I - Interface Segregation Principle: Interfaces should be specific to the client, avoiding the creation of general interfaces that require clients to implement unnecessary functions.

• D - Dependency Inversion Principle: Modules should depend on abstractions, not on concrete implementations. This reduces dependencies between modules and facilitates code testing and development.

KISS

KISS, which stands for Keep It Simple, Stupid, is a principle encouraging the writing of simple, understandable code. Avoiding excessive complexity is crucial for maintaining code readability and maintainability. The more complex the code, the more difficult it is to understand and modify in the future. Using simple solutions, clear variable and function names, and avoiding excessive nesting of conditions and loops are key practices consistent with the KISS principle.

DRY

DRY, which stands for Don't Repeat Yourself, is a principle advocating for the avoidance of code repetition. Any repeated code fragments should be refactored into separate functions or classes, allowing for easier code management and maintenance. Repeated code is difficult to maintain because it requires changes in multiple places when modifications are necessary. By adhering to the DRY principle, code becomes more modular and flexible.

Data Types in Python

Integers: These are whole numbers, such as 1, 100, -5, etc. Python allows for basic arithmetic operations on integers, such as addition +, subtraction -, multiplication *, division /, integer division //, and modulo operations %.

Floats: These include floating-point numbers, e.g. 3.14, 2.5, -0.5, etc. They are used to represent decimal numbers. Python supports mathematical operations on floating-point numbers such as addition, subtraction, multiplication, and division.

Strings: These are sequences of characters enclosed in quotation marks, e.g. “Hello, World!”. In Python, strings are immutable objects, meaning they cannot be modified after creation. Python offers many string operations, such as concatenation +, indexing [], slicing [start:stop:step], and many methods for text manipulation.

Lists: Lists are collections of elements that can be of different types. We create them using square brackets [], e.g. [1, 2, 3]. Lists in Python are mutable, meaning we can add, remove, and modify their elements.

Tuples: Tuples are similar to lists but are immutable collections of elements. We create them using parentheses (), e.g. (1, 2, 3). Tuples are more memory-efficient than lists because they occupy less space in memory, but they cannot be modified after creation.

Dictionaries: Dictionaries are collections of key-value pairs, where each key is unique. We create them using curly braces {}, e.g. {“key”: “value”, “name”: “Anna”}. Dictionaries allow fast access to values by key and are used to store data in the form of pairs.

Unittest Library

The unittest library is part of Python's standard library and provides tools for creating and running unit tests. Here's an example of a simple unit test in unittest:

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

class TestMathOperations(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(-1, 1), 0)
        self.assertEqual(add(0, 0), 0)
if __name__ == '__main__':
    unittest.main()

Pytest tool

Pytest is a more modern testing tool in Python and offers a more transparent and convenient syntax than unittest.

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

def test_addition():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

With pytest, we don't need to inherit from a class or use special assertions, making test writing more clear and concise.

Data Structures in Pandas

DataFrame is the main data structure in Pandas, resembling a database table or spreadsheet. It consists of rows and columns, and each column can have a different data type. We can create a DataFrame from various data sources, such as CSV files, databases, other DataFrames, etc.

import pandas as pd
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'Los Angeles', 'Chicago']}
df = pd.DataFrame(data)
print(df)

Series is a one-dimensional data structure in Pandas, representing a single column or row in a DataFrame. Each value in a Series is indexed, allowing for fast data operations.

import pandas as pd
numbers = pd.Series([10, 20, 30, 40, 50])
print(numbers)

Basic Data Manipulations using pandas

import pandas as pd
df = pd.read_csv('file_name.csv') # reading data from CSV file

df.head() # displays first data rows
df.info() # displays basic information about data
df.describe() # displays basic statistics for numeric values
filtered_df = df[df['example_column'] > warunek] # filtering of rows meeting condition

column_data = df['example_column'] # selecting data from one column
subset = df[['example_column1', 'example_column2']] # selecting multiple columns
df['new_example_column'] = values # adding new column

df.dropna() # removing rows with missing values
df.drop(['example_column1', 'example_column2'], axis=1) # removing specific columns
grouped_df = df.groupby('example_column').mean() # grouping data and counting mean value

merged_df = pd.merge(df1, df2, on='key') # connecting data frames
df['example_column'] = df['example_column'].astype('new_type') # changing data in the column
sorted_df = df.sort_values(by='example_column', ascending=False) # sorting data

Pandas allows extensive manipulation, analysis, and basic as well as advanced plotting using other libraries like matplotlib and seaborn. Unfortunately, pandas and data visualization are too extensive topics for this modest article.

Key Features of FastAPI

Simple Example of Running FastAPI

To install FastApi in the terminal, type the command:

pip install fastapi uvicorn

Then create a file named main.py

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/add")
def add_numbers(x: int, y: int):
    return {"result": x + y}

Next, run the application using uvicorn

uvicorn main:app --reload

Now, open a browser and go to http://localhost:8000/docs. The API documentation will be automatically generated using Swagger.

FastAPI offers many more capabilities, such as handling different types of requests (POST, PUT, DELETE), file handling, creating dependencies, automatic API testing, and much more. It's a great tool for building modern and efficient web applications using Python.