Python: Wiedza w pigułce, którą każdy powinien mieć

SOLID

SOLID to mnemonik określający pięć podstawowych zasad projektowania obiektowego:

• S - Single Responsibility Principle (Zasada pojedynczej odpowiedzialności): Klasa powinna mieć tylko jedną odpowiedzialność, czyli być odpowiedzialna za jedną konkretną funkcjonalność. Dzięki temu unikamy zbyt dużych i złożonych klas, co ułatwia zarządzanie kodem.

• O - Open/Closed Principle (Zasada otwarte/zamknięte): Klasa powinna być otwarta na rozszerzenie, ale zamknięta na modyfikację. Zmiany w klasie powinny być dokonywane poprzez dodawanie nowego kodu, a nie zmienianie istniejącego.

• L - Liskov Substitution Principle (Zasada podstawienia Liskov): Obiekty danej klasy powinny być zastępowalne przez obiekty ich podklas bez zmiany działania programu. Dzięki temu zachowujemy spójność i elastyczność kodu.

• I - Interface Segregation Principle (Zasada segregacji interfejsów): Interfejsy powinny być konkretne dla danego klienta, unikamy tworzenia ogólnych interfejsów, które wymagają od klientów implementowania niepotrzebnych funkcji.

• D - Dependency Inversion Principle (Zasada odwrócenia zależności): Moduły powinny być zależne od abstrakcji, a nie od konkretnych implementacji. Dzięki temu zmniejszamy zależności między modułami i ułatwiamy testowanie oraz rozwijanie kodu.

KISS

KISS, czyli Keep It Simple, Stupid, to zasada zachęcająca do pisania prostego, zrozumiałego kodu. Unikanie nadmiernego skomplikowania jest kluczowe dla utrzymania czytelności i łatwości utrzymania kodu. Im bardziej skomplikowany kod, tym trudniejsze jest jego zrozumienie i modyfikacja w przyszłości. Stosowanie prostych rozwiązań, klarownych nazw zmiennych i funkcji oraz unikanie nadmiernego zagnieżdżania warunków i pętli są kluczowymi praktykami zgodnymi z zasadą KISS.

DRY

DRY, czyli Don’t Repeat Yourself, to zasada mówiąca o unikaniu powtarzania się kodu. Wszelkie powtarzające się fragmenty kodu powinny być zrefaktoryzowane do oddzielnych funkcji lub klas, co pozwala na łatwiejsze zarządzanie i utrzymanie kodu. Powtarzający się kod jest trudny w utrzymaniu, ponieważ wymaga zmian w wielu miejscach w przypadku konieczności modyfikacji. Dzięki zastosowaniu zasady DRY, kod staje się bardziej modułowy i elastyczny.

Typy danych w Pythonie

Integers (liczby całkowite): Są to liczby całkowite, takie jak 1, 100, -5 itp. Python pozwala na wykonywanie podstawowych operacji arytmetycznych na liczbach całkowitych, takich jak dodawanie +, odejmowanie -, mnożenie *, dzielenie /, dzielenie całkowite // oraz operacje modulo %.

Floats (liczby zmiennoprzecinkowe): Obejmują liczby zmiennoprzecinkowe, np. 3.14, 2.5, -0.5 itp. Są używane do reprezentowania liczb dziesiętnych. Python obsługuje operacje matematyczne na liczbach zmiennoprzecinkowych takie jak dodawanie, odejmowanie, mnożenie i dzielenie.

Strings (łańcuchy znaków): Są to sekwencje znaków umieszczone w cudzysłowiu, np. “Hello, World!”. W Pythonie łańcuchy znaków są niezmiennymi obiektami, co oznacza, że po utworzeniu nie można ich modyfikować. Python oferuje wiele operacji na łańcuchach, takich jak konkatenacja +, indeksowanie [], wycinanie [start:stop:step] oraz wiele metod do manipulacji tekstem.

Lists (listy): Listy są kolekcjami elementów, które mogą być różnych typów. Tworzymy je za pomocą nawiasów kwadratowych [], np. [1, 2, 3]. Listy w Pythonie są mutowalne, co oznacza, że można dodawać, usuwać i modyfikować ich elementy.

Tuples (krotki): Krotki są podobne do list, ale są niezmiennymi kolekcjami elementów. Tworzymy je za pomocą nawiasów okrągłych (), np. (1, 2, 3). Krotki są bardziej wydajne od list, gdyż zajmują mniej miejsca w pamięci, ale nie można ich modyfikować po utworzeniu.

Dictionaries (słowniki): Słowniki to kolekcje par klucz-wartość, gdzie każdy klucz jest unikalny. Tworzymy je za pomocą nawiasów klamrowych {}, np. {“klucz”: “wartość”, “imie”: “Anna”}. Słowniki umożliwiają szybkie dostęp do wartości poprzez klucz i są używane do przechowywania danych w formie par.

Biblioteka unittest

Biblioteka unittest jest częścią biblioteki standardowej Pythona i zapewnia narzędzia do tworzenia i uruchamiania testów jednostkowych. Oto przykład prostego testu jednostkowego w 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()

Narzędzie pytest

Pytest jest bardziej nowoczesnym narzędziem do testowania w Pythonie i oferuje bardziej przejrzystą i wygodną składnię niż 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

W przypadku pytest nie musimy dziedziczyć z klasy czy używać specjalnych asercji, co sprawia, że pisanie testów jest bardziej przejrzyste i kompaktowe.

Struktury danych w Pandas

DataFrame jest główną strukturą danych w Pandas, przypominającą tabelę bazy danych lub arkusz kalkulacyjny. Składa się z wierszy i kolumn, a każda kolumna może mieć inny typ danych. Możemy tworzyć DataFrame z różnych źródeł danych, takich jak pliki CSV, bazy danych, inne DataFrame itp.

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 jest jednowymiarową strukturą danych w Pandas, reprezentującą pojedynczą kolumnę lub wiersz w DataFrame. Każda wartość w Series jest indeksowana, co umożliwia szybkie operacje na danych

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

Podstawowe manipulacje na danych za pomocą pandasa

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 pozwala na obszerną manipulację analizę oraz na tworzenie wykresów podstawowych jak i zaawansowanych za pomocą innych bibliotek jak matplotlib oraz seaborn. Niestety pandas i wizualizacja danych jest zbyt obszernym tematem jak na ten skromny artykuł.

Główne cechy FastAPI

Prosty Przykład jak uruchomić FastAPI

Aby zainstalować FastApi w terminalu wpisujemy polecenie:

pip install fastapi uvicorn

Następnie tworzymy plik 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}

Następnie uruchamiamy aplikację za pomocą uvicorn

uvicorn main:app --reload

Teraz uruchamiamy przeglądarkę i wchodzimy pod adres http://localhost:8000/docs. Dokumentacja API zostanie automatycznie wygenerowana za pomocą Swagger.

FastAPI oferuje znacznie więcej możliwości, takich jak obsługa różnych typów żądań (POST, PUT, DELETE), obsługa plików, tworzenie zależności, testowanie automatyczne API i wiele innych. Jest to świetne narzędzie do budowy nowoczesnych i wydajnych aplikacji webowych z wykorzystaniem Pythona.