DEV Community: Karol

📚 My Python Roadmap Journey #6 – Object-Oriented Programming (OOP)

Karol — Wed, 24 Sep 2025 18:32:13 +0000

(PL) – Object-Oriented Programming w Pythonie
Minął kolejny etap mojej ścieżki – tym razem skupiłem się na programowaniu obiektowym (OOP). To zagadnienie kluczowe, bo właśnie ono pozwala łączyć dane i logikę w spójną całość, a także organizować większe projekty w czytelny sposób. Zdecydowanie jest to jeden z tematów, który nie jest prosty ale daje satysfakcję, gdy poznaje się jego tajemnice.

Przerobione zagadnienia:

Klasy i obiekty
Dziedziczenie i polimorfizm
Metody (instancyjne, klasowe, statyczne)
Enkapsulacja (@property)
Metody specjalne („dundery”)
Mixiny i kompozycja
Klasy abstrakcyjne (ABC) i Protocol
Context Manager (with)
Własne wyjątki

Ćwiczenie
Zamiast kilku prostych skryptów przygotowałem jeden większy projekt – Mini Library Manager.
Projekt symuluje katalog biblioteczny, w którym można dodawać książki, e-booki i czasopisma, wyszukiwać je, a także wypożyczać i zwracać z pomocą sesji działającej jak transakcja (rollback przy błędzie).
Dzięki temu mogłem w praktyce zastosować praktycznie wszystkie mechanizmy OOP w Pythonie – od prostych klas i dziedziczenia, po protokoły, dundery i context manager. To jeden z bardziej skomplikowanych kodów jaki napisałem.

🔗 Kod dostępny na GitHubie: https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/OOP

Wnioski
To jak dotąd najbardziej wymagający etap, ale jednocześnie najbardziej satysfakcjonujący. Widzę, jak bardzo OOP porządkuje kod i daje fundamenty do większych projektów.

🔜 Kolejne wyzwanie: Package managers, Common packages, Paradigms.

Do usłyszenia 🖐🏼

(ENG) – Object-Oriented Programming in Python
Another step on my learning path – this time I focused on Object-Oriented Programming (OOP). It’s a key concept since it allows combining data and logic in a structured way, and organizing larger projects into clean, reusable components. This is definitely one of the topics that is not simple, but it gives satisfaction when you learn its secrets.

Covered topics:

Classes and objects
Inheritance and polymorphism
Instance, class, and static methods
Encapsulation with @property
Special methods (dunders)
Mixins and composition
Abstract Base Classes (ABC) & Protocol
Context Manager (with)
Custom exceptions

Exercise
Instead of many small scripts, I built one bigger project – Mini Library Manager.
It simulates a library catalog where you can add books, e-books, and magazines, search them, and manage loans with a session that works like a transaction (rollback on error).
This allowed me to apply nearly every OOP mechanism in Python in practice – from simple classes and inheritance to protocols, dunders, and context managers.

🔗 Code available on GitHub: https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/OOP

Conclusion
So far, this has been the most challenging stage, but also the most rewarding. I see how much OOP helps in structuring code and provides a solid foundation for larger projects.

🔜 Next step: Package managers, Common packages, Paradigms.

see you later🖐🏼

📚 My Python Roadmap Journey #5 - Python Concepts

Karol — Sun, 07 Sep 2025 19:05:51 +0000

(ENG below)
Kolejne kroki – Python Concepts
Idąc zgodnie z planem nauki, tym razem skupiłem się na tematach, które w mojej ocenie pozwalają pisać kod w sposób bardziej profesjonalny i elastyczny. Nie są to już podstawowe konstrukcje języka ani typowe struktury danych – to narzędzia, które naprawdę zmieniają styl pracy z Pythonem.

Przerobione zagadnienia:

Modules
Lambdas
Decorators
Iterators
Regular Expressions

Każdy z tych elementów ma ogromne znaczenie w codziennym programowaniu:
Modules pomagają uporządkować kod i ułatwiają ponowne użycie.
Lambdas są świetne, gdy potrzebuję prostej funkcji „na szybko”.
Decorators pozwalają rozszerzyć działanie funkcji i klas bez dotykania ich kodu.
Iterators umożliwiają przechodzenie po danych krok po kroku, co jest nieocenione przy dużych zbiorach.
Regular Expressions to potężne narzędzie do analizy i walidacji tekstów.

Ćwiczenia
Aby utrwalić materiał, przygotowałem kilka mini-projektów:
text_utils – moduł z funkcjami do pracy z tekstem (iteratory + regex).
logger – dekoratory do logowania czasu i wywołań funkcji.
user_filter – filtrowanie danych użytkowników z użyciem lambd, regexów i iteratora.
password_gen – generator i iterator haseł z dekoratorami walidującymi.

Całość jak zawsze można znaleźć na GitHubie:
👉 https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Python_Concepts

To był etap, w którym poczułem, że Python daje naprawdę ogromne możliwości pisania zwięzłego, czytelnego i sprytnego kodu.

🔜 Kolejny krok: Object-Oriented Programming (OOP) – klasy, dziedziczenie i wzorce projektowe.

Do usłyszenia ✋

(ENG)
Next steps – Advanced Python Concepts
Following my learning plan, this time I focused on topics that, in my opinion, make code more professional and flexible. These are not just basic language constructs or data structures – these are tools that truly change the way you write Python.

Covered topics:

Modules
Lambdas
Decorators
Iterators
Regular Expressions

Each of these plays an important role in daily coding:
Modules help organize and reuse code.
Lambdasare perfect for small functions on the fly.
Decorators extend functions and classes without modifying their code.
Iterators let you process data step by step, which is essential for large datasets.
Regular Expressions are a powerful tool for text validation and parsing.

Exercises
To practice, I created several mini-projects:
text_utils – a module for text processing (iterators + regex).
logger – decorators for logging execution time and calls.
user_filter – filtering user data using lambdas, regex, and a custom iterator.
password_gen – a password generator and iterator with validation decorators.

Everything is available on GitHub:
👉 https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Python_Concepts

This stage made me realize how powerful Python can be when it comes to writing concise, readable, and clever code.

🔜 Next step: Object-Oriented Programming (OOP) – classes, inheritance, and design patterns.

See you soon ✋

Pygame #1 - small project

Karol — Thu, 04 Sep 2025 15:35:18 +0000

(ENG below)
Od kiedy zacząłem powtarzać Pythona, w mojej głowie pojawił się pomysł stworzenia jakiegoś mini projektu z wykorzystaniem Pygame. Zastanawiałem się jednak co mogę stworzyć, aż do przedwczoraj kiedy to moim oczom ukazała się reklama na YouTube. Postanowiłem ją odtworzyć we własnym zakresie.

Tak powstał projekt Ball Bounces - gra/symulator, w której piłki odbijają się wewnątrz okręgu, rysują linie, przejmują je od siebie nawzajem, a zwycięża ostatnia żywa piłka lub ta, która pierwsza zdobędzie 100 punktów.

Od pomysłu do kodu
Podstawą gry jest okrąg narysowany w Pythonie

def draw_arena(surface):
    pygame.draw.circle(surface, (240, 240, 240), CENTER, ARENA_R, 3)

Piłki to obiekty klasy Ball, która przechowuje swoją pozycję, prędkość, listę zdobytych "anchorów" oraz liczbę punktów.

class Ball:
    def __init__(self, color):
        self.color = color
        self.pos = CENTER.copy()
        self.vel = pygame.Vector2(random.uniform(-1,1), random.uniform(-1,1)) * 200
        self.hit_points = []
        self.score = 0

Kolizje, były dość problematyczne ponieważ mamy ich kilka:

piłka - ściana: klasyczne odbicie wektora prędkości,
piłka - piłka: sprężyste zderzenie równych mas,
piłka - linia: sub-stepping i test odległości punkt-odcinek, aby uniknąć gubienia przejęć przy większej prędkości.

Przejęcia lini to jeden z ciekawszych elementów - założenie było takie aby piłka która przecina linię przeciwnika, dostawała nowy anchor i punkt, a przeciwnik je tracił. W przypadku gdy był to ostatni anchor przeciwnika - kulka "umiera" i jest usuwana z gry.

Sterowanie i tryby
Grę można uruchomić w trybie 2,3 lub 4 graczy.

Sterowanie jest banalne:

S - start,
R - restart,
2 / 3 / 4 - wybór liczby graczy.

Efekt końcowy
Gra dość szybko staje się chaotyczna - linie krzyżują się, piłki przejmują nawzajem swoje punkty, a plansza zamienia się w sieć kolorowych linii. Dokładnie takiego efektu oczekiwałem. Dodatkowo można obstawiać, która kulka wygra.

Kod źródłowy
Cały projekt do obejrzenia na moim Githubie:
https://github.com/Karol-Polak/Ball_Bounces/tree/main

Podsumowanie
"Ball Bounces" to świetny przykład, jak ciekawe efekty można uzyskać korzystając z Pygame. Mam już pomysły na kolejne update'y, które mogłyby znaleźć się w grze.

Do usłyszenia 👋🏼

Since I started revising Python, I had the idea of building a small project with Pygame. I was wondering what I could build, until the day before yesterday when I saw an ad on Youtube. I decided to recreate it on my own.

That's how the project Ball Bounces was created - a game/simulator where balls bounce inside a circle, draw lines, steal them from each other, and the winner is either the last ball alive or the one that first reaches 100 points.

From idea to code
The foundation of the game is a circle drawn in Python.

def draw_arena(surface):
    pygame.draw.circle(surface, (240, 240, 240), CENTER, ARENA_R, 3)

The balls are objects of the Ball class, which stores their position, velocity, the list of collected "anchors", and the score.

class Ball:
    def __init__(self, color):
        self.color = color
        self.pos = CENTER.copy()
        self.vel = pygame.Vector2(random.uniform(-1,1), random.uniform(-1,1)) * 200
        self.hit_points = []
        self.score = 0

Collisions turned out to be quite tricky because there are several types:

ball - wall: classic velocity vector reflection,
ball - ball: elastic collision of equal masses,
ball - line: sub-stepping and point-to-segment distance test to avoid missing captures at higher speeds.

Linę capturing is one of the most interesting elements - the assumption was that if a ball crosses an opponent's line, it receives a new anchor and a point, while the opponent loses them. If it was the opponent's last anchor, their ball "dies" and is removed from the game.

Contols and modes
The game can be launched in 2,3 or 4 player mode.
Contols are simple:

S - start,
R - restart,
2 / 3 / 4 - choose the number of players.

Final effect
The game quickly becomes chaotic - lines cross, balls steal each other's points, and the board turns into a web colorful lines. That's exactly the effect I was hoping for. Additionally, you can even bet on which ball will win.

Source Code
The entire project is available on my Github:
https://github.com/Karol-Polak/Ball_Bounces/tree/main

Summary
"Ball Bounces" is a great example of how interesting effects can be achieved with Pygame. I already have ideas for future updates that could make their way into the game.

See you 👋🏼

📚 My Python Roadmap Journey #3 & #4 - Data Structures & Algorithms

Karol — Wed, 03 Sep 2025 14:17:44 +0000

(ENG below)
Minęło trochę czasu od ostatniego wpisu, ale nie był to czas stracony. Tym razem skupiłem się na zagadnieniach, które w mojej ocenie wymagają więcej uwagi oraz skupienia, a przede wszystkim cierpliwości. Choć nie mogę powiedzieć, że były to dla mnie nowe tematy, to po czasie przy ich powtarzaniu miałem wrażenie, jak gdyby część wiedzy zupełnie mi uciekła. Muszę przyznać, że zrozumienie a następnie implementacja praktyczna tych zagadnień daje ogromną satysfakcję.

Przerobione zagadnienia:

Arrays and Linked Lists
Hash Tables
Heaps, Stacks and Queues
Binary Search Tree
Recursion
Sorting Algorithms

Każdy z tych tematów okazał się ciekawy na swój urokliwy sposób. Najwięcej zabawy sprawiły mi stosy i kolejki - o ile ich implementacja w Pythonie jest prosta, to dokładne zrozumienie "dlaczego działają tak, a nie inaczej" daje sporo satysfakcji. Również rekurencja, którą często traktowałem jako dość oczywistą rzecz, pokazała mi swoje mocne strony przy implementacji klasycznych problemów jak wieże Hanoi czy Quicksort.

Zgodnie z założeniami postarałem się przygotować małe projekty dla każdego poznanego zagadnienia, można je znaleźć na moim Githubie:
https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Data_Structures

To były najbardziej wymagające zagadnienia jak do tej pory na mojej drodze, ale tego się spodziewałem. Wiem jednak, że te fundamenty będą przydatne zarówno w praktyce programistycznej, jak i podczas przyszłych rozmów technicznych.

Kolejne wyzwania, o których niedługo napiszę:
Modules, Lambdas, Decorators, Iterators and Regular Expressions

Do usłyszenia!

It’s been a while since my last post, but it wasn’t a waste of time. This time, I focused on issues that, in my opinion, require more attention, concentration, and above all patience. Although I can't say that these were new topics for me, after some time, when I repeated them, I had the feeling that some of the knowledge had completely slipped away from me. I must admit that understanding and then implementing these concepts in practice is extremely satisfying.

Revised topics:

Arrays and Linked Lists
Hash Tables
Heaps, Stacks, and Queues
Binary Search Tree
Recursion
Sorting Algorithms

Each of these topics turned out to be interesting in its own charming way. I particularly enjoyed working with stacks and queues - while their implementation in Python is simple, understanding exactly "why they work this way and not that way" is very satisfying. Recursion, which I often considered a rather obvious thing, also showed me its strengths in implementing classic problems like the Towers of Hanoi or Quicksort.

I have tried to prepare small projects for each of the topics, which can be found on my GitHub:
https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Data_Structures

These were the most challenging topics I have faced so far, but I expected that. However, I know that these basics will be useful both in programming practice and in future technical interviews.

The next challenges, which I will write about soon:
Modules, Lambdas, Decorators, Iterators, and Regular Expressions

See you!

📚 My Python Roadmap Journey #2 - Basics

Karol — Thu, 28 Aug 2025 20:40:24 +0000

(ENG below)
Robię postępy, a przynajmniej tak mi się wydaje. Nie zatrzymuję się w moim postanowieniu i aktualnie kończę podstawy. Czuję, że przerobiony materiał oraz na jego bazie wykonane ćwiczenia stanowią solidny fundament całego Pythona. Zdecydowanie to dopiero początek ale już nie mogę się doczekać kolejnych tematów.

Zgodnie z założeniami udało mi się przerobić następujące tematy:

Type Casting
Exceptions
Functions and Builtin Functions
Lists, Tuples, Sets
Dictionaries

Kilka wolnych wniosków na każde z zagadnień:
Type casting - pozwala bezproblemowo zamieniać dane między typami, zarówno z inputu, jak i z plików.
Exceptions - bardzo wygodne rozwiązanie, które pozwala programowi poradzić sobie z błędami zamiast się wysypywać.
Functions - porządkują kod, pomagają uniknąć powtórzeń, a wbudowane funkcje pozwalają zaoszczędzić ogromne ilości czasu.
Lists, Tuples, Sets - każda z nich ma inne zastosowanie, a odpowiedni wybór ma wpływ na wydajność i prostotę rozwiązania.
Dictionaries - podstawa w Pythonie, pozwalają przechowywać dane w formacie klucz - wartość, dają szybki dostęp i przejrzyste przechowywanie danych.

Zgodnie z założeniami wykonałem kilka prostych programów obejmujących zagadnienia, przy czym bardzo dobrze się bawiłem. Jak zawsze wszystko dostępne jest na moim Githubie.

Github: https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Basics%232

Nie zatrzymuję się i kontynuuję naukę bo przede mną zagadnienia Data Structures & Algorithms. Do usłyszenia niedługo.

I’m making progress, or at least that’s what I think. I am not stopping in my resolution and I am currently finishing the basics. I feel that the revised material and the exercises based on it form a solid foundation for the entire Python. It’s definitely just the beginning, but I can’t wait for the next topics.

I was able to cover the following topics as planned:

Type Casting
Exceptions
Functions and Built-in Functions
Lists, Tuples, Sets
Dictionaries

A few free suggestions for each of the issues:
Type casting - allows you to easily convert data between types, both from input and from files.
Exceptions - a very convenient solution that allows the program to handle errors instead of crashing.
Functions - they organize the code, help avoid repetition, and built-in functions save a huge amount of time.
Lists, Tuples, Sets - each has a different use, and the right choice affects the efficiency and simplicity of the solution.
Dictionaries - the foundation in Python, they allow you to store data in a key-value format, provide quick access and transparent data storage.

I made a few simple programs covering the topics, and I had a lot of fun. As always, everything is available on my GitHub.

Github: https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Basics#2

I don't stop and continue learning because Data Structures & Algorithms are ahead of me. See you soon.

📚 My Python Roadmap Journey #1 - Basics

Karol — Thu, 28 Aug 2025 10:28:16 +0000

(ENG below)
Pierwsze kroki... kiedyś wydawały się trudne, natomiast teraz to bułka z masłem. Chcąc ułatwić sobie cały proces oraz usystematyzować materiał skorzystałem z gotowego planu nauki na roadmap.sh.

Na start podjąłem się przypomnienia zagadnień:

Basic Syntax
Variables and Data Types
Conditionals
Loops

Mając już gotowy plan oraz materiały do nauki zacząłem powtarzać wybrane zagadnienia. Nie zajęło mi to wiele czasu, jednak ponowne spojrzenie na dokumentację oraz materiały online pozwoliło mi przypomnieć sobie drobne niuanse. Z "nową" wiedzą przystąpiłem do napisania kilku prostych programów, które w założeniu miały wykorzystywać dopiero co powtórzone zagadnienia. Ich treść można sprawdzić na moim Githubie (https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Basics%231)

Nie zwlekając od razu zabrałem się za kolejne powtórki.

The first steps... used to seem difficult, but now they're a piece of cake. To make the whole process easier and to organize the material, I used a ready-made learning plan from roadmap.sh.

At the start, I undertook to recall the issues:

Basic Syntax
Variables and Data Types
Conditionals
Loops

Having already prepared a plan and study materials, I began to review the selected topics. It didn't take me long, but re-reading the documentation and online materials helped me remember the small nuances. With "new" knowledge, I started writing a few simple programs that were supposed to use the concepts I had just reviewed. Their content can be checked on my GitHub (https://github.com/Karol-Polak/Python_roadmap_journey/tree/main/Basics#1)

I didn't hesitate and immediately started reviewing the next topics.

📚My Python Roadmap Journey - Prolog

Karol — Tue, 26 Aug 2025 18:29:02 +0000

(ENG below)
Słów kilka na początek... Pythonem zainteresowałem się w trakcie pierwszych studiów na WAT, kiedy to miałem zajęcia "podstawy programowania". Zachęcony bardzo ciekawym sposobem przedstawienia zagadnienia jakim jest programowanie postanowiłem na własną rękę zgłębić temat. W następstwie przez kolejne dni, a później tygodnie czytałem dokumentację oraz oglądałem różne treści na YouTube. Po ponad roku, kiedy pracowałem zarobkowo, postanowiłem zrobić krok w kierunku podjęcia nowych studiów i tak wylądowałem na WIT, który miał stać się dla mnie przepustką do branży IT.

Nie będę rozwodził się nad etapami mojego życia, jednak wszystkie decyzje doprowadziły mnie do pracy w Orange.

Stawiając sobie kolejne wyzwanie postanowiłem przejść raz jeszcze drogę nauki języka Python, a ten 'blog' ma być moim pamiętnikiem oraz dodatkowym motywatorem.

Zamieszczane tu treści skupiać się będą na kolejnych etapach nauki, moich przemyśleniach oraz spostrzeżeniach. Jeżeli zainteresowałem Cię tematem serdecznie zapraszam do śledzenia mojej przygody.

A few words to start... I became interested in Python during my first studies at WAT, when I had a "programming basics" class. Encouraged by the very interesting way of presenting the issue of programming, I decided to delve deeper into the subject on my own. As a result, I read documentation and watched various content on YouTube for days, and later weeks. After more than a year, when I was working for a living, I decided to take a step towards taking new studies and that's how I ended up at WIT, which was supposed to be my ticket to the IT industry.

I won't go into the details of the stages of my life, but all the decisions led me to work at Orange.

I set myself another challenge, I decided to go through the process of learning Python once again, and this 'blog' is to be my diary and an additional motivator.

The content posted here will focus on the next stages of learning, my thoughts and observations. If I have piqued your interest in the topic, I cordially invite you to follow my adventure.