Część 7 - Python

Moduł w całości poświęcony jest zaawansowanemu przetwarzaniu łańcuchów znaków (typ str) w języku Python. Omówiono w nim mechanizmy indeksowania dodatniego i ujemnego, wycinki (slicing) z krokiem oraz zasadę niemutowalności napisów. Przedstawiono bogaty zestaw wbudowanych metod tekstowych, takich jak split(), join(), replace(), strip() i wiele innych, umożliwiających wygodną manipulację danymi tekstowymi. Szczegółowo przeanalizowano techniki formatowania tekstu, od operatora % i metody format(), aż po najnowocześniejsze f-stringi z obsługą wyrażeń i formatowania liczb. Materiał zawiera również praktyczne programy i ćwiczenia, w tym analizator tekstu, walidator e-mail oraz generator raportów.

Kluczowe zagadnienia modułu:

Indeksowanie, wycinki i niemutowalność — dostęp do znaków, wyodrębnianie fragmentów [start:stop:krok] oraz konsekwencje niezmienności typu str
Wbudowane metody tekstowe — split(), join(), replace(), strip(), upper(), lower(), find(), count() i inne do transformacji i wyszukiwania danych
Nowoczesne formatowanie tekstu — operator %, metoda format() i f-stringi z wyrażeniami, formatowaniem liczb oraz wyrównaniem do boków
Znaki specjalne i raw stringi — sekwencje ucieczki \n, \t, \\ oraz surowe napisy r"" do pracy ze ścieżkami i wyrażeniami regularnymi
Programy i ćwiczenia praktyczne — analizator tekstu, walidator e-mail, formatowanie raportów, odwracanie słów, palindrom i cenzurowanie tekstu

Streszczenie - Łańcuchy znaków i metody tekstowe

Moduł poświęcony łańcuchom znaków stanowi jeden z kluczowych elementów kursu, ponieważ umiejętność sprawnego przetwarzania tekstu jest niezbędna w każdej dziedzinie programowania. Typ str w Pythonie został zaprojektowany z myślą o maksymalnej wygodzie i wydajności, oferując bogaty zestaw wbudowanych metod oraz elastyczne mechanizmy formatowania. Zrozumienie różnic między poszczególnymi technikami łączenia i przekształcania tekstów pozwala na pisanie kodu, który jest nie tylko poprawny, ale również optymalny pod kątem zużycia pamięci. Szczególnie ważne jest opanowanie f-stringów, które stanowią obecnie standard w nowoczesnym kodzie Python.

W praktyce inżynierskiej przetwarzanie tekstu obejmuje także walidację danych wejściowych, ekstrakcję informacji z logów systemowych oraz generowanie raportów w czytelnej formie. Metody takie jak split(), join() i replace() są codziennie używane przez miliony programistów na całym świecie, a ich dobre opanowanie znacznie przyspiesza pisanie kodu. Warto również zwrócić uwagę na mechanizm String Interning, który automatycznie optymalizuje wykorzystanie pamięci przy pracy z napisami.

Łańcuchy znaków (ang. strings) w języku Python reprezentowane są przez wbudowany typ tekstowy str.
Służą one do przechowywania oraz wygodnego przetwarzania dowolnych informacji tekstowych, od pojedynczych liter po całe książki.
Kluczową cechą łańcuchów znaków w Pythonie jest ich niemutowalność (ang. immutability), co oznacza, że raz stworzony napis nie może zostać zmodyfikowany w pamięci komputera.
Każda operacja, która wydaje się zmieniać tekst (np. zamiana liter na wielkie), w rzeczywistości tworzy i zwraca zupełnie nowy obiekt tekstowy.
Pod maską łańcuch znaków jest sekwencją, co oznacza, że zachowuje on stałą kolejność znaków i pozwala na ich sekwencyjne odczytywanie.

Zapamiętaj: Pamiętaj, że w Pythonie typ str jest niezmienny. Próba modyfikacji poszczególnych znaków w miejscu zawsze zakończy się błędem TypeError.

tekst = "Witaj w Pythonie!"
print(type(tekst))  # <class 'str'>

Łańcuchy znaków w Pythonie są implementowane jako tablice bajtów w kodowaniu Unicode, co oznacza, że mogą przechowywać znaki z praktycznie każdego języka świata, w tym polskie znaki diakrytyczne. Niemutowalność typu str nie jest wadą, lecz świadomym wyborem projektowym, który zwiększa bezpieczeństwo wielowątkowych aplikacji oraz umożliwia interpreterowi stosowanie zaawansowanych optymalizacji pamięciowych. Każda operacja na stringach, która wydaje się modyfikować tekst, w rzeczywistości tworzy nowy obiekt w pamięci.

Dzięki temu, że string jest sekwencją, dziedziczy on wszystkie cechy tego typu danych: może być indeksowany, wycinany, iterowany oraz łączony z wykorzystaniem standardowych operatorów. Wbudowana funkcja len() pozwala błyskawicznie określić długość napisu, a operator in umożliwia sprawdzenie, czy dany podciąg znajduje się w tekście. Te właściwości czynią string jednym z najbardziej elastycznych i najczęściej używanych typów danych w Pythonie.

W Pythonie łańcuchy znaków możemy tworzyć na kilka równorzędnych sposobów przy użyciu różnych rodzajów cudzysłowów.
Najpopularniejsze są cudzysłowy pojedyncze (apostrofy) oraz cudzysłowy podwójne, które w działaniu są całkowicie tożsame.
Użycie obu wariantów pozwala na wygodne zagnieżdżanie jednego typu cudzysłowu wewnątrz drugiego bez konieczności stosowania znaków ucieczki.
Do tworzenia napisów wielolinijkowych lub dokumentacji funkcji stosujemy potrójne cudzysłowy (pojedyncze lub podwójne).
Zachowują one automatycznie wszystkie znaki nowej linii oraz wcięcia, co czyni je idealnymi do długich bloków tekstu.

Zapamiętaj: Wybierz jeden styl cudzysłowów (np. pojedyncze lub podwójne) i stosuj go konsekwentnie w całym projekcie zgodnie z przewodnikiem PEP 8.

jedne = 'Napis w pojedynczych'
dwupunkt = "Napis z 'apostrofem' w środku"
wielolinijkowy = """To jest tekst
który zajmuje
kilka linii."""

Wybór rodzaju cudzysłowu przy tworzeniu napisów w Pythonie ma wpływ nie tylko na czytelność kodu, ale także na sposób, w jaki interpreter przetwarza znaki specjalne wewnątrz tekstu. Potrójne cudzysłowy są szczególnie przydatne przy definiowaniu docstringów, czyli dokumentacji funkcji i klas, którą Python przechowuje jako atrybut __doc__ i którą można odczytać za pomocą funkcji help().

Należy pamiętać, że w Pythonie nie ma różnicy między apostrofami a cudzysłowami, jednak konwencja PEP 8 zaleca wybór jednego stylu i trzymanie się go konsekwentnie w całym projekcie. W sytuacjach, gdy tekst zawiera apostrofy, wygodniej jest użyć cudzysłowów, aby uniknąć stosowania znaków ucieczki.

Ponieważ łańcuch znaków jest uporządkowaną sekwencją, każdy znak w tekście posiada przypisany do siebie unikalny numer, czyli indeks.
Python stosuje standardowe indeksowanie rozpoczynające się od zera, co oznacza, że pierwszy znak ma indeks 0.
Aby uzyskać dostęp do konkretnego znaku, używamy nawiasów kwadratowych zapisanych bezpośrednio po nazwie zmiennej tekstowej, np. s[0].
Drugi znak ma indeks 1, trzeci indeks 2 i tak dalej, aż do ostatniego elementu.
Proces ten działa niezwykle szybko (w czasie stałym O(1)), ponieważ Python precyzyjnie oblicza adres znaku w pamięci.
Metoda ta pozwala na natychmiastowe pobieranie pojedynczych liter z dowolnie długiego napisu.

Zapamiętaj: Indeksowanie służy wyłącznie do odczytu danych. Próba przypisania nowej wartości pod dany indeks, np. s[0] = 'A', wywoła błąd.

jezyk = "Python"
pierwszy = jezyk[0]  # 'P'
trzeci = jezyk[2]    # 't'
print(pierwszy, trzeci)

Indeksowanie od zera jest standardem przyjętym w większości nowoczesnych języków programowania, wywodzącym się bezpośrednio ze sposobu działania pamięci operacyjnej komputerów. Wskaźnik do pierwszego elementu tablicy ma zawsze przesunięcie równe zero, dlatego pierwszy znak znajduje się pod indeksem 0, a nie 1.

Próba odwołania się do nieistniejącego indeksu skutkuje wyjątkiem IndexError, którego obsługa wymaga zastosowania mechanizmów wyłapywania błędów. Aby uniknąć tego typu problemów, przed dostępem do konkretnego znaku warto zweryfikować długość napisu za pomocą funkcji len().

Genialną i niezwykle wygodną funkcją Pythona jest wsparcie dla ujemnego indeksowania sekwencji.
Pozwala ono na szybki dostęp do znaków liczony od końca łańcucha tekstowego, bez potrzeby ręcznego wyznaczania jego długości.
Indeks -1 zawsze wskazuje na ostatni znak w napisie, indeks -2 na przedostatni, a -3 na trzeci od końca.
Jest to niesamowicie przydatne przy analizowaniu rozszerzeń plików lub sprawdzaniu ostatnich znaków w liniach tekstu.
Dzięki ujemnym indeksom eliminujemy skomplikowane i nieczytelne konstrukcje matematyczne wymagające użycia funkcji len().

Zapamiętaj: Zawsze używaj indeksu -1, aby odwołać się do ostatniego znaku. To znacznie bardziej czytelne niż konstrukcja s[len(s) - 1].

napis = "Programowanie"
ostatni = napis[-1]    # 'e'
przedostatni = napis[-2]  # 'i'
print(ostatni, przedostatni)

Indeksy ujemne są jednym z tych elementów Pythona, które docenia się dopiero po dłuższym czasie pracy z tym językiem. W większości innych języków programowania dostęp do ostatniego elementu wymaga obliczenia długości sekwencji, co wydłuża kod i zmniejsza jego czytelność. Python eliminuje tę niedogodność, umożliwiając liczenie od końca za pomocą ujemnych wartości, gdzie -1 oznacza zawsze ostatni element.

Szczególnie przydatne jest to przy analizie rozszerzeń plików, gdzie chcemy szybko sprawdzić ostatnie znaki, lub przy walidacji adresów e-mail. Indeksowanie ujemne doskonale współpracuje z wycinkami, co pozwala na tworzenie bardzo zwięzłych konstrukcji, takich jak pobranie ostatnich N znaków czy odwrócenie tekstu.

Podczas pracy z indeksowaniem łańcuchów znaków najczęstszą pułapką jest próba sięgnięcia po indeks, który nie istnieje w danym napisie.
Jeśli nasz tekst ma długość N znaków, poprawne indeksy dodatnie mieszczą się wyłącznie w przedziale od 0 do N-1.
Próba odwołania się do indeksu równego lub większego niż N (np. s[N]) spowoduje natychmiastowe zgłoszenie wyjątku IndexError.
Podobnie dzieje się przy indeksowaniu ujemnym, gdzie najmniejszy dopuszczalny indeks to -N.
Aby zabezpieczyć swój program przed nagłym przerwaniem działania, warto przed pobraniem znaku sprawdzić długość tekstu.

Zapamiętaj: Zawsze pamiętaj, że pusty łańcuch znaków (o długości 0) nie posiada żadnych poprawnych indeksów -- próba pobrania s[0] zawsze wywoła IndexError.

tekst = "Kot"  # długość 3, indeksy: 0, 1, 2
try:
    znak = tekst[5]
except IndexError as e:
    print(f"Błąd: {e}")  # string index out of range

Błąd IndexError jest jednym z najczęstszych wyjątków, z jakimi spotyka się początkujący programistą i pojawia się nie tylko przy pracy ze stringami, ale również z listami, krotkami i innymi sekwencjami. Komunikat błędu zawiera informację o tym, który indeks był niepoprawny oraz o dopuszczalnym zakresie wartości, co znacznie ułatwia debugowanie.

Dobrą praktyką jest zawsze sprawdzanie długości sekwencji przed próbą dostępu do jej elementu, szczególnie gdy dane pochodzą od użytkownika lub z zewnętrznych źródeł. W przypadku wycinków Python jest bardziej wyrozumiały i nie zgłasza błędu przy przekroczeniu zakresu, co jest celowym zachowaniem ułatwiającym pisanie bezpiecznego kodu.

Wycinki (ang. slicing) to jedna z najpotężniejszych technik w Pythonie, pozwalająca na wyodrębnianie fragmentów (podłańcuchów) z tekstu.
Składnia wycinków wykorzystuje zapis s[start:stop], gdzie start to indeks początkowy (włącznie), a stop to indeks końcowy (wyłącznie).
Oznacza to, że znak znajdujący się pod indeksem stop nie zostanie dołączony do wynikowego podłańcucha.
Zwrócony fragment jest zawsze nowym obiektem typu str, podczas gdy oryginalny napis pozostaje nienaruszony.
Technika ta jest niezwykle bezpieczna, ponieważ w przeciwieństwie do zwykłego indeksowania, wycinki nie generują błędu IndexError przy przekroczeniu zakresu.

Zapamiętaj: Przedział w wycinkach jest prawostronnie otwarty [start, stop). Znak pod indeksem stop jest pomijany!

kurs = "Python_Kurs"
fragment1 = kurs[0:6]   # 'Python'
fragment2 = kurs[7:11]  # 'Kurs'
print(fragment1, fragment2)

Wycinki są jednym z najsilniejszych argumentów przemawiających za nauką Pythona, ponieważ oferują niezwykle zwięzłą i elegancką składnię do wyodrębniania fragmentów danych. W innych językach ta sama operacja wymagałaby napisania pętli lub użycia zewnętrznych bibliotek, podczas gdy w Pythonie wystarczy jeden krótki zapis z dwukropkiem.

Warto zapamiętać, że wycinki zawsze zwracają nowy obiekt, nie modyfikując oryginalnego napisu, co jest zgodne z ogólną zasadą niemutowalności stringów. Bezpieczeństwo wycinków przejawia się w tym, że nawet przy próbie wycięcia fragmentu wykraczającego poza długość tekstu, Python nie zgłosi błędu, a jedynie zwróci tyle znaków, ile jest dostępnych.

Pełna składnia wycinania w Pythonie pozwala na zdefiniowanie trzeciego, opcjonalnego parametru, czyli kroku: s[start:stop:krok].
Krok (ang. step) określa, o ile pozycji ma przesuwać się wskaźnik podczas pobierania kolejnych znaków z tekstu.
Domyślnie krok wynosi 1, co oznacza pobieranie każdego znaku po kolei bez pomijania żadnego.
Zdefiniowanie kroku równego 2 spowoduje pobieranie co drugiego znaku, a kroku 3 -- co trzeciego.
Co ciekawe, krok może być również wartością ujemną, co wymusza na Pythonie przeglądanie tekstu w kierunku wstecznym.

Zapamiętaj: Wycinki z krokiem są niezwykle szybkie, ponieważ cała logika przeskakiwania po indeksach realizowana jest bezpośrednio na poziomie zoptymalizowanego kodu C.

napis = "AbCdEfG"
co_drugi = napis[0:7:2]  # 'ACEG' (tylko wielkie litery)
print(co_drugi)

Parametr kroku w wycinkach otwiera zupełnie nowy poziom możliwości manipulacji tekstem, pozwalając na wybiórcze pobieranie znaków z określoną regularnością. Na przykład wycinek s[0:10:2] zwróci co drugi znak z pierwszych dziesięciu, co może być przydatne przy dekompresji prostych kodów lub analizie wzorców w danych.

Należy pamiętać, że przy ujemnym kroku domyślne wartości start i stop również się odwracają – jeśli krok jest ujemny, Python zakłada, że chcemy przeglądać sekwencję od końca do początku. Dlatego zapis s[::-1] jest tak potężny i jednocześnie prosty w użyciu.

Podczas tworzenia wycinków w Pythonie możemy swobodnie pomijać dowolne z trzech pól w nawiasie kwadratowym: start, stop lub krok.
Pominięcie indeksu start (np. s[:stop]) oznacza, że wycinanie rozpocznie się od samego początku tekstu (od indeksu 0).
Pominięcie indeksu stop (np. s[start:]) nakazuje Pythonowi wycięcie znaków aż do samego końca napisu.
Z kolej pominięcie obu tych wartości (zapis s[:]) utworzy dokładną kopię całego łańcucha tekstowego.
Te sprytne skróty składniowe znacząco zwiększają czytelność kodu i są powszechnie stosowane przez doświadczonych programistów.

Zapamiętaj: Używanie domyślnych wartości w wycinkach jest standardem w Pythonie. Zapis s[:5] jest o wiele bardziej elegancki niż s[0:5].

tekst = "SuperKomputer"
poczatek = tekst[:5]   # 'Super'
koniec = tekst[5:]     # 'Komputer'
print(poczatek, koniec)

Możliwość pomijania parametrów w wycinkach to kolejny przykład dbałości twórców Pythona o ergonomię języka. Zapis s[:5] jest nie tylko krótszy, ale też bardziej czytelny niż s[0:5], ponieważ od razu widać, że interesuje nas początek napisu. Podobnie s[5:] intuicyjnie oznacza fragment od piątego znaku do końca.

Zapis s[:] to popularny idiom służący do tworzenia płytkiej kopii sekwencji, który w przypadku stringów zwraca nowy obiekt o tej samej wartości. W kontekście list i innych mutowalnych typów jest to ważna technika zabezpieczająca przed niechcianymi modyfikacjami.

Niemutowalność (ang. immutability) oznacza, że obiekt tekstowy po utworzeniu w pamięci nie może podlegać żadnym modyfikacjom.
Próba przypisania nowego znaku pod konkretny indeks (np. s[0] = 'X') zakończy się natychmiastowym błędem TypeError.
Niemutowalność ta przynosi ogromne korzyści w zakresie bezpieczeństwa działania programów oraz optymalizacji pamięci RAM.
Dzięki temu łańcuchy znaków mogą być bezpiecznie współdzielone przez różne części aplikacji bez ryzyka ich przypadkowej zmiany.
Jeśli potrzebujemy zmodyfikować tekst, musimy zbudować nowy łańcuch znaków, łącząc odpowiednie wycinki i nowe znaki.

Zapamiętaj: Niemutowalność chroni strukturę danych przed efektami ubocznymi. Gwarantuje to, że tekst przekazany do funkcji nie zostanie w niej niespodziewanie zmieniony.

imie = "Jan"
try:
    imie[0] = "P"  # Wywoła TypeError
except TypeError as e:
    print(f"Błąd: {e}")
nowe_imie = "P" + imie[1:]  # Tworzenie nowego napisu 'Pan'

Niemutowalność typów danych w Pythonie nie ogranicza się wyłącznie do stringów – dotyczy również krotek, frozensetów oraz liczb. Jest to świadoma decyzja projektowa, która upraszcza rozumowanie o programie, eliminując efekty uboczne przy przekazywaniu argumentów do funkcji.

Konsekwencją niemutowalności jest konieczność tworzenia nowych obiektów przy każdej modyfikacji tekstu, co w przypadku intensywnych operacji w pętlach może prowadzić do spadku wydajności. Dlatego w sytuacjach, gdy potrzebujemy często modyfikować tekst, zaleca się użycie listy znaków i przekształcenie jej na string dopiero na końcu.

Do wyznaczania dokładnej liczby znaków składających się na dany napis służy uniwersalna, wbudowana funkcja len().
Funkcja ta zwraca liczbę całkowitą (int) reprezentującą rozmiar łańcucha znaków.
Warto pamiętać, że len() zlicza absolutnie wszystkie znaki tworzące tekst, w tym litery, cyfry, znaki interpunkcyjne, a także spacje i niewidoczne znaki specjalne (np. tabulatory czy znaki nowej linii).
Wywołanie len() jest niezwykle wydajne i wykonuje się w czasie stałym O(1).
Dzieje się tak, ponieważ Python przechowuje informację o długości napisu bezpośrednio w nagłówku obiektu w pamięci, dzięki czemu nie musi fizycznie przeliczać znaków przy każdym wywołaniu.

Zapamiętaj: Używaj len(), aby weryfikować długość wejścia od użytkownika, np. sprawdzając minimalną długość hasła lub poprawność numeru PESEL.

tekst = "Python 3"
dlugosc = len(tekst)  # 8 (litery, spacja oraz cyfra)
print(f"Długość napisu: {dlugosc}")

Funkcja len() jest jedną z najczęściej używanych funkcji wbudowanych w Pythonie, a jej działanie wykracza daleko poza proste zliczanie znaków. Dzięki implementacji w języku C działa ona w czasie stałym O(1) dla wszystkich wbudowanych typów kolekcyjnych, ponieważ każdy obiekt przechowuje swoją długość jako atrybut wewnętrzny.

W kontekście walidacji danych len() jest niezastąpione przy sprawdzaniu minimalnej i maksymalnej długości wprowadzanych tekstów, takich jak hasła czy numery PESEL. Warto pamiętać, że len() dla pustego stringa zwraca 0, co jest przydatne przy sprawdzaniu, czy użytkownik cokolwiek wpisał.

Łączenie łańcuchów znaków (ang. concatenation) realizujemy w Pythonie najprościej za pomocą operatora dodawania +.
Operator ten pobiera dwa napisy i scala je w jeden, nowy obiekt tekstowy, zachowując kolejność znaków.
Ważne jest, aby pamiętać, że w Pythonie nie można bezpośrednio dodać liczby do tekstu przy użyciu operatora +.
Taka próba wywoła błąd TypeError, dlatego każdą wartość nieliczbową należy najpierw jawnie przekonwertować na napis za pomocą funkcji str().
W przypadku łączenia dużej liczby stringów w pętli, używanie operatora + jest mało efektywne i należy zastąpić je metodą .join().

Zapamiętaj: Unikaj wielokrotnego łączenia napisów za pomocą '+' w pętli. Każde takie dodawanie zmusza system do alokowania nowej pamięci i kopiowania danych.

powitanie = "Witaj" + " " + "Świecie!"
wersja = 3
komunikat = "Python " + str(wersja)  # Jawna konwersja liczby
print(powitanie, komunikat)

Operator + do łączenia stringów jest intuicyjny i wygodny, ale ma swoją cenę wydajnościową przy wielokrotnym użyciu w pętli. Każde wywołanie s1 + s2 tworzy nowy obiekt w pamięci, kopiując do niego zawartość obu łączonych napisów, co przy N iteracjach daje złożoność kwadratową O(N²).

Rozwiązaniem tego problemu jest użycie metody join(), która najpierw oblicza łączną długość wszystkich elementów, alokuje pamięć dokładnie raz, a następnie wypełnia ją danymi. Dla małych operacji różnica jest pomijalna, ale przy łączeniu tysięcy fragmentów join() może skrócić czas wykonania z sekund do milisekund.

Kolejną unikalną i niezwykle wygodną cechą języka Python jest możliwość powielania (multiplikacji) tekstu za pomocą operatora mnożenia *.
Działanie to polega na pomnożeniu łańcucha znaków przez liczbę całkowitą N, co w efekcie zwraca nowy napis składający się z N-krotnie powtórzonego wzorca.
Zastosowanie ujemnego mnożnika lub zera spowoduje wygenerowanie pustego łańcucha znaków.
Technika ta jest niesamowicie przydatna podczas rysowania elementów interfejsu konsolowego, tworzenia linii oddzielających sekcje w raportach tekstowych lub przygotowywania nagłówków.
Pozwala to na uniknięcie pisania niepotrzebnych pętli generujących powtarzalne wzorce tekstowe.

Zapamiętaj: Mnożnik w operatorze '*' musi być zawsze liczbą całkowitą (int). Próba pomnożenia stringa przez float (np. s * 1.5) wywoła błąd TypeError.

linia = "-" * 30
napis = "Python!" * 3
print(linia)
print(napis)
print(linia)

Operator mnożenia * dla stringów to jedna z tych cech Pythona, która wydaje się oczywista dopiero po jej poznaniu, ale znacznie ułatwia pisanie kodu. Wewnętrznie interpreter implementuje tę operację w zoptymalizowanym kodzie C, wykorzystując funkcję memcpy, która kopiuje bloki pamięci z maksymalną wydajnością.

W praktyce programistycznej operator * jest używany do generowania separatorów w raportach, tworzenia prostych wizualizacji konsolowych oraz przygotowywania szablonów tekstowych. W połączeniu z metodą center() pozwala na szybkie tworzenie nagłówków otoczonych ozdobnikami.

Do weryfikacji, czy określony fragment tekstu (podłańcuch) znajduje się wewnątrz innego napisu, używamy operatora przynależności in.
Zwraca on wartość logiczną True, jeśli szukany ciąg znaków istnieje w przeszukiwanym tekście, lub False w przeciwnym razie.
Podobnie możemy skorzystać z operatora not in, który zwraca True, gdy podany fragment nie występuje w napisie.
Operacje te są niezwykle czytelne, przypominają naturalny język i są w pełni zoptymalizowane pod kątem wydajności wyszukiwania.
Wyszukiwanie jest wrażliwe na wielkość liter, dlatego 'Py' i 'py' będą traktowane jako zupełnie inne ciągi znaków.

Zapamiętaj: Używanie operatora 'in' jest najbardziej pythonowym i najszybszym sposobem na sprawdzenie obecności podciągu w tekście.

tekst = "Nauka języka Python to przyjemność."
print("Python" in tekst)      # True
print("Java" in tekst)        # False
print("C++" not in tekst)       # True

Operator in w Pythonie jest implementowany za pośrednictwem metody magicznej __contains__, którą można przeciążyć we własnych klasach. Dla stringów wewnętrzna implementacja używa zaawansowanych algorytmów wyszukiwania, co zapewnia wysoką wydajność nawet dla długich tekstów.

Operator in działa również w drugą stronę – można go użyć do iterowania po elementach sekwencji w pętli for. To dwukierunkowe działanie czyni go jednym z najważniejszych elementów składni Pythona. W kontekście walidacji formularzy pozwala na szybkie sprawdzenie, czy adres e-mail zawiera znak @.

Łańcuchy znaków w Pythonie posiadają bogaty zestaw wbudowanych metod ułatwiających manipulację tekstem.
Metoda .upper() tworzy i zwraca nowy napis, w którym wszystkie małe litery zostały zamienione na ich wielkie odpowiedniki.
Z kolei metoda .lower() działa odwrotnie -- konwertuje wszystkie wielkie litery na małe.
Obie te metody całkowicie ignorują znaki, które nie są literami (np. cyfry, spacje czy znaki interpunkcyjne).
Są one niezwykle przydatne przy realizowaniu bezwzględnego porównywania tekstów wprowadzanych przez użytkownika (ang. case-insensitive comparison), gdzie chcemy zignorować wielkość wpisanych liter.

Zapamiętaj: Ponieważ stringi są niemutowalne, metody .upper() i .lower() nie zmieniają oryginalnej zmiennej, lecz zwracają nowy napis, który należy przypisać do zmiennej.

napis = "Python 3.10"
wielkie = napis.upper()  # 'PYTHON 3.10'
male = napis.lower()      # 'python 3.10'
print(wielkie, male)

Metody upper() i lower() są przykładem szerszej kategorii metod transformujących tekst, które respektują reguły językowe Unicode, a nie tylko podstawową tablicę ASCII. Oznacza to, że polskie znaki takie jak ą, ć, ę, ń, ó, ś, ź, ż zostaną poprawnie przekształcone na wersje wielkie lub małe.

W codziennej pracy metody te są niezbędne przy normalizacji danych przed porównaniem, szczególnie przy wyszukiwaniu i sortowaniu. Włączenie .lower() do łańcucha wywołań metody to standardowa technika w Pythonie, pozwalająca na pisanie bardzo zwięzłego kodu.

Podczas pobierania danych od użytkownika (np. za pomocą input() lub z plików) na końcach tekstu często pojawiają się zbędne spacje, tabulatory czy znaki nowej linii.
Do ich błyskawicznego usuwania służy wbudowana metoda .strip(), która oczyszcza tekst zarówno z lewej, jak i z prawej strony.
Jeśli chcemy oczyścić napis tylko z jednej strony, możemy użyć odpowiednio metody .lstrip() (usuwanie z lewej) lub .rstrip() (usuwanie z prawej).
Podobnie jak inne metody, strip() nie modyfikuje oryginalnego łańcucha, lecz zwraca jego czystą kopię.
Metoda ta ma kluczowe znaczenie przy walidacji formularzy i przygotowywaniu danych do zapisu.

Zapamiętaj: Domyślnie strip() usuwa wszystkie białe znaki (spacje, tabulatory '\t', nową linię '\n'). Możesz też przekazać opcjonalny argument z zestawem znaków do usunięcia.

surowy = "  \t Witaj Świecie! \n  "
czysty = surowy.strip()
print(f"Przed: '{surowy}'")
print(f"Po: '{czysty}'")

Metoda strip() jest jednym z podstawowych narzędzi przygotowania danych przed ich właściwym przetwarzaniem, ponieważ dane z plików czy formularzy prawie zawsze zawierają zbędne białe znaki na końcach. Ignorowanie tego faktu prowadzi do trudnych do wykrycia błędów przy porównywaniu stringów.

Możliwość przekazania niestandardowego zestawu znaków do usunięcia czyni strip() jeszcze bardziej wszechstronnym. Na przykład strip(".!?") oczyści tekst ze znaków interpunkcyjnych na krańcach. W połączeniu z replace() i split() tworzy solidny fundament do przetwarzania tekstu.

Do zamiany określonych fragmentów tekstu na inne służy niezwykle przydatna metoda .replace(stary, nowy).
Metoda ta wyszukuje w napisie wszystkie wystąpienia ciągu znaków podanego jako pierwszy argument i zastępuje je ciągiem podanym jako drugi argument.
Co ważne, jeśli szukany fragment nie zostanie znaleziony, metoda nie zgłasza błędu, lecz po prostu zwraca nienaruszony, oryginalny tekst.
Metoda .replace() pozwala również na przekazanie trzeciego, opcjonalnego parametru numerycznego określającego maksymalną liczbę zamian do wykonania od lewej strony.
Jest to podstawowe narzędzie przy cenzurowaniu słów lub formatowaniu surowych tekstów.

Zapamiętaj: Metoda .replace() tworzy całkowicie nowy obiekt str w pamięci komputera. Oryginalny łańcuch znaków pozostaje niezmieniony.

tekst = "Java to super język. Java jest szybka."
nowy = tekst.replace("Java", "Python")
limitowany = tekst.replace("Java", "Python", 1)
print(nowy)
print(limitowany)

Metoda replace() działa na zasadzie wyszukiwania wzorca i zastępowania go nowym tekstem, przy czym wyszukiwanie odbywa się od lewej do prawej strony napisu. Opcjonalny trzeci parametr limit pozwala na precyzyjne kontrolowanie liczby zastąpień, co jest przydatne przy edycji nagłówków.

Mimo swojej prostoty replace() jest niezwykle potężnym narzędziem w codziennej pracy. Jest używane do czyszczenia danych, maskowania poufnych informacji, poprawiania typowych błędów literowych. Warto pamiętać, że replace() nie wspiera wyrażeń regularnych – do bardziej zaawansowanych zadań należy użyć modułu re.

Metoda .split() służy do rozbijania (dzielenia) jednego łańcucha znaków na listę mniejszych podłańcuchów (listę obiektów typu str).
Domyślnie, jeśli nie przekażemy żadnego argumentu, split() dokonuje podziału tekstu według wszelkich białych znaków (spacje, tabulatory, znaki nowej linii), automatycznie ignorując wielokrotne spacje obok siebie.
Możemy również zdefiniować własny separator (np. przecinek, średnik czy ukośnik), przekazując go jako argument metody, np. .split(',').
Metoda ta jest absolutnie kluczowa podczas przetwarzania plików CSV, analizowania logów serwerowych czy parsowania argumentów wejściowych w programach konsolowych.

Zapamiętaj: Wywołanie .split() na pustym stringu bez podania separatora zwraca pustą listę [], co jest bardzo bezpiecznym i wygodnym zachowaniem.

zdanie = "Python to super język"
slowa = zdanie.split()  # ['Python', 'to', 'super', 'język']
dane_csv = "Jan,Kowalski,30"
osoba = dane_csv.split(",")  # ['Jan', 'Kowalski', '30']
print(slowa, osoba)

Metoda split() jest jednym z najważniejszych narzędzi przy parsowaniu tekstów strukturalnych, takich jak pliki CSV czy logi serwerowe. Domyślne zachowanie, polegające na dzieleniu według białych znaków z pomijaniem pustych fragmentów, jest zaskakująco przydatne w praktyce.

W zaawansowanych zastosowaniach split() jest łączony z map() do przekształcania ciągów tekstowych na struktury danych. Parametr maxsplit pozwala na ograniczenie liczby podziałów. Zrozumienie różnicy między split() a rsplit() pozwala na precyzyjną kontrolę nad kierunkiem dzielenia.

Metoda .join() działa dokładnie odwrotnie do metody .split() -- służy do szybkiego i wydajnego łączenia listy napisów w jeden spójny łańcuch tekstowy.
Składnia tej metody bywa na początku zaskakująca dla nowicjuszy, ponieważ wywołujemy ją na stringu będącym separatorem, a listę napisów przekazujemy jako argument, np. separator.join(lista).
Jako separator możemy użyć spacji, przecinka, myślnika, a nawet pustego stringa '', jeśli chcemy połączyć słowa bezpośrednio ze sobą.
Pod kątem wydajności pamięciowej .join() jest bezkonkurencyjny i powinien być zawsze używany zamiast dodawania elementów w pętli za pomocą operatora +.

Zapamiętaj: Wszystkie elementy w przekazywanej liście muszą być typu str. Obecność jakiejkolwiek liczby w liście wywoła błąd TypeError.

slowa = ["Python", "jest", "super"]
zdanie = " ".join(slowa)      # 'Python jest super'
scalone = "-".join(slowa)     # 'Python-jest-super'
print(zdanie, scalone)

Metoda join() jest odwrotnością split() i służy do scalania kolekcji elementów w jeden spójny napis. Jej składnią w której separator wywołuje metodę na sobie, bywa na początku myląca, ale ma głębokie uzasadnienie w architekturze Pythona.

Wydajność join() jest szczególnie widoczna przy łączeniu dużych kolekcji, gdzie różnica w stosunku do operatora + może być nawet kilkudziesięciokrotna. Metoda ta jest niezastąpiona przy generowaniu zapytań SQL czy łączeniu elementów HTML. Wszystkie elementy kolekcji muszą być typu str.

Wyszukiwanie pozycji określonego podciągu w tekście możemy zrealizować za pomocą dwóch wbudowanych metod: .find() oraz .index().
Obie metody pobierają jako parametr szukany łańcuch znaków i zwracają indeks (liczbę całkowitą) reprezentujący pozycję pierwszego wystąpienia tego ciągu od lewej strony.
Kluczowa różnica między nimi polega na sposobie obsługi sytuacji, gdy szukany tekst nie zostanie znaleziony.
Metoda .find() zwraca wówczas bezpieczną wartość -1, co nie przerywa działania programu.
Z kolei metoda .index() zgłasza w takiej sytuacji wyjątek ValueError, co zmusza nas do stosowania bloków try-except w celu przechwycenia błędu.

Zapamiętaj: Używaj metody .find(), gdy nie masz pewności, czy szukany podciąg w ogóle istnieje w tekście, aby uniknąć obsługi wyjątków.

tekst = "Akademia Pythona"
poz1 = tekst.find("Python")  # 9
poz2 = tekst.find("Java")    # -1 (bezpieczna wartość)
print(poz1, poz2)

Różnica między metodami find() i index() jest doskonałym przykładem filozofii Pythona preferującej jawne komunikaty błędów. Metoda find() zwraca -1 dla braku wyniku, podczas gdy index() rzuca wyjątek ValueError, wymuszając na programiście świadomą obsługę sytuacji.

Obie metody przyjmują opcjonalne parametry start i stop ograniczające obszar poszukiwań. W przeciwieństwie do operatora in, który zwraca tylko informację logiczną, find() i index() podają dokładną pozycję wystąpienia, co umożliwia dalsze operacje na tekście.

Do szybkiego zliczania, ile razy dany podciąg znaków występuje w tekście, służy bardzo wygodna metoda .count(szukany).
Zwraca ona liczbę całkowitą reprezentującą ilość pełnych, nienakładających się na siebie wystąpień szukanego wzorca.
Metoda ta pozwala na przekazanie dwóch opcjonalnych parametrów numerycznych: start oraz stop, które ograniczają zakres przeszukiwania do konkretnego wycinka tekstu.
Podobnie jak inne operacje wyszukiwania w Pythonie, .count() jest wrażliwa na wielkość liter, co należy uwzględnić przy analizie tekstów naturalnych.
Jest to podstawowe narzędzie przy tworzeniu prostych statystyk tekstowych czy weryfikacji częstotliwości występowania słów.

Zapamiętaj: Metoda .count() zlicza wyłącznie nienakładające się na siebie wystąpienia. Dla tekstu 'aaaa' i szukanego 'aa' count() zwróci wartość 2, nie 3.

zdanie = "bananowy koktajl bananowy"
ilosc1 = zdanie.count("banan")  # 2
ilosc2 = zdanie.count("a")      # 5
print(f"Banan: {ilosc1}, litera a: {ilosc2}")

Metoda count() jest wydajnym narzędziem do statystycznej analizy tekstu działającym w czasie liniowym O(N). Ważnym aspektem jest fakt, że count() zlicza wystąpienia nienachodzące na siebie – dla wzorca ″aa″ w tekście ″aaaa″ da wynik 2.

W praktyce count() znajduje zastosowanie przy analizie częstotliwości występowania słów, weryfikacji liczby znaków specjalnych w logach czy sprawdzaniu poprawności formatu adresów e-mail. W połączeniu z parametrami start/stop umożliwia zaawansowane przeszukiwanie tekstu.

Bardzo często zachodzi potrzeba sprawdzenia, czy dany łańcuch znaków rozpoczyna się lub kończy określonym frazem tekstowym.
Do tego celu Python udostępnia dwie niezwykle czytelne metody logiczne: .startswith(prefiks) oraz .endswith(sufiks).
Metoda .startswith() weryfikuje początek tekstu, natomiast .endswith() sprawdza jego zakończenie, zwracając True lub False.
Obie metody są powszechnie wykorzystywane przy filtrowaniu plików (np. szukaniu rozszerzeń .py czy .txt) lub weryfikacji poprawności protokołów internetowych (np. sprawdzaniu czy adres URL zaczyna się od https://).
Co ciekawe, jako argument możemy przekazać krotkę (tuple) kilku napisów, a Python sprawdzi czy którykolwiek z nich pasuje.

Zapamiętaj: Metody te są znacznie szybsze i bardziej odporne na błędy niż ręczne wycinanie fragmentów tekstu typu s[:5] == 'https'.

plik = "skrypt.py"
url = "https://python.org"
print(plik.endswith(".py"))         # True
print(url.startswith("https://"))  # True
print(plik.endswith((".py", ".txt"))) # True (sprawdza krotkę)

Metody startswith() i endswith() są często niedoceniane przez początkujących, którzy zamiast nich używają ręcznego wycinania fragmentów tekstu. Tymczasem są one nie tylko bardziej czytelne, ale również wydajniejsze, ponieważ interpreter może zastosować optymalizacje na poziomie kodu C.

W praktyce startswith() jest niezastąpione przy parsowaniu URL-i, a endswith() przy filtrowaniu plików według rozszerzenia. W połączeniu z os.listdir() pozwalają na szybkie wyszukanie wszystkich plików .py w katalogu.

Do szybkiego i wygodnego formatowania wielkości liter w tekstach służą metody .capitalize() oraz .title().
Metoda .capitalize() zamienia pierwszą literę całego łańcucha na wielką, a wszystkie pozostałe litery w tekście konwertuje na małe.
Z kolei metoda .title() zmienia na wielką pierwszą literę każdego pojedynczego słowa w tekście, co jest idealne do formatowania imion, nazwisk czy tytułów książek.
Warto pamiętać, że obie metody zwracają całkowicie nowy łańcuch znaków i nie modyfikują oryginalnego obiektu tekstowego.
Metody te są podstawą przy automatycznym czyszczeniu i standaryzowaniu baz danych osobowych.

Zapamiętaj: Metoda .title() może zachować się nieoczekiwanie przy słowach z apostrofem (np. 'O\'Brian' zamieni na 'O\'Brian'), zamieniając literę po apostrofie na wielką.

tekst = "witaj w PIĘKNYM pythonie"
kapital = tekst.capitalize()  # 'Witaj w pięknym pythonie'
tytul = tekst.title()            # 'Witaj W Pięknym Pythonie'
print(kapital)
print(tytul)

Metody title() i capitalize() są wygodnym narzędziem do szybkiego formatowania tekstu, ale mają pewne ograniczenia. Title() zamienia pierwszą literę każdego słowa na wielką, co jest zgodne z angielskimi regułami tytułów, ale w języku polskim nie zawsze daje poprawne rezultaty.

W aplikacjach biznesowych metody te są używane do standaryzacji danych osobowych. Dla zaawansowanego formatowania uwzględniającego reguły polskie konieczne jest jednak użycie zewnętrznych bibliotek. W połączeniu z strip() i replace() stanowią podstawowe narzędzie czyszczenia baz danych.

Przed przystąpieniem do operowania na danych tekstowych od użytkownika niezwykle ważna jest ich dokładna walidacja w celu uniknięcia błędów wykonania.
Do sprawdzania charakteru znaków tworzących tekst służą metody rozpoczynające się od słowa 'is'.
Metoda .isdigit() zwraca True, jeśli tekst składa się wyłącznie z cyfr i nie zawiera żadnych innych znaków (nawet spacji czy minusa).
Metoda .isalpha() sprawdza, czy w tekście znajdują się wyłącznie litery, natomiast .isalnum() weryfikuje, czy tekst składa się wyłącznie z liter i cyfr (brak znaków specjalnych).
Wszystkie te metody zwracają False, jeśli badany łańcuch znaków jest całkowicie pusty.

Zapamiętaj: Metoda .isdigit() zwróci False dla liczb ujemnych (z powodu znaku '-') oraz ułamków (z powodu kropki '.'). Do walidacji liczb zmiennoprzecinkowych użyj bloku try-except.

wiek = "25"
tekst = "Python"
print(wiek.isdigit())   # True
print(tekst.isalpha())  # True
print("Pro 100".isalnum()) # False (ze względu na spację)

Metody isdigit(), isalpha() i isalnum() należą do grupy metod walidacyjnych zwracających wartości logiczne. Ich główną zaletą jest prostota użycia i wysoka wydajność. Wszystkie zwracają False dla pustego stringa.

W praktyce isdigit() weryfikuje wiek lub kod pocztowy przed konwersją na typ liczbowy. Isalpha() znajduje zastosowanie przy walidacji pól imienia. Należy pamiętać, że metody te nie są wystarczające do pełnej walidacji – isdigit() zwróci False dla liczby ujemnej.

Podczas tworzenia czytelnych raportów tekstowych wyświetlanych w konsoli bardzo przydatne są metody służące do pozycjonowania i wyrównywania tekstu.
Metoda .ljust(szerokość) wyrównuje tekst do lewej strony, dopełniając go z prawej spacjami do określonej długości pola.
Metoda .rjust(szerokość) wyrównuje napis do prawej strony, natomiast .center(szerokość) umieszcza tekst idealnie na środku pola.
Wszystkie te metody pozwalają na przekazanie opcjonalnego, drugiego argumentu znakowego, który zastąpi domyślne spacje wybranym znakiem wypełniającym (np. kropką czy myślnikiem).
Dzięki temu możemy łatwo generować ładne spisy treści czy obramowania tekstowe.

Zapamiętaj: Jeśli podana szerokość pola jest mniejsza lub równa aktualnej długości łańcucha znaków, metody te zwrócą oryginalny napis bez żadnych zmian.

slowo = "Test"
lewa = slowo.ljust(10, "-")   # 'Test------'
prawa = slowo.rjust(10, "*")   # '******Test'
srodek = slowo.center(10, " ") # '   Test   '
print(lewa)
print(prawa)
print(srodek)

Metody center(), ljust() i rjust() to narzędzia pozycjonowania tekstu w konsoli, szczególnie przydatne przy raportach. Działają przez dopełnienie napisu do określonej szerokości, co zapewnia równomierne wyrównanie kolumn.

W praktyce zestawienie tych metod z f-stringami pozwala na tworzenie zaawansowanych układów tabelarycznych. Opcjonalny parametr fillchar umożliwia użycie dowolnego znaku jako wypełniacza. Metody te są używane w generowaniu diagramów ASCII w konsoli.

Formatowanie tekstu polega na dynamicznym wstrzykiwaniu wartości zmiennych w określone miejsca szablonu tekstowego.
Najstarszą metodą formatowania w Pythonie jest użycie operatora %, zwanego często formatowaniem w stylu printf z języka C.
W szablonie umieszcza się specjalne specyfikatory formatu, takie jak %s dla tekstu, %d dla liczb całkowitych oraz %f dla liczb zmiennoprzecinkowych.
Po szablonie zapisuje się operator % oraz krotkę zawierającą zmienne, które mają zostać wstrzyknięte w odpowiednie miejsca.
Choć ta metoda jest wciąż wspierana, uważa się ją za przestarzałą i mało czytelną przy dużej liczbie zmiennych, dlatego w nowym kodzie należy jej unikać.

Zapamiętaj: Formatowanie za pomocą operatora '%' nie jest zalecane w nowoczesnym Pythonie i ustępuje miejsca czytelniejszym f-stringom.

imie = "Jan"
wiek = 25
szablon = "Cześć %s, masz %d lat." % (imie, wiek)
print(szablon)

Operator % do formatowania tekstu pochodzi z języka C i był pierwszym mechanizmem formatowania w Pythonie. Mimo że uznaje się go za przestarzały na rzecz f-stringów, wciąż występuje w starszym kodzie. Specyfikatory %ś %d, %f kontrolują typ wstawianej wartości.

Główną wadą operatora % jest spadek czytelności przy większej liczbie zmiennych. Mimo ograniczeń wciąż znajduje zastosowanie w logowaniu i komunikatach błędów, gdzie prostota zapisu jest ważniejsza niż elastyczność.

W Pythonie 3 wprowadzono nowocześniejszą i znacznie bardziej elastyczną metodę formatowania tekstu za pomocą metody .format().
W tym podejściu szablon tekstowy zawiera specjalne nawiasy klamrowe {}, które pełnią rolę zastępników (ang. placeholders) na zmienne.
Metoda .format() przyjmuje argumenty, które są automatycznie wstrzykiwane w klamry zgodnie z kolejnością ich podania w wywołaniu.
Pozwala ona na pozycjonowanie zmiennych za pomocą indeksów numerycznych (np. {0}, {1}) lub nazywanie ich (np. {imie}, {wiek}), co znacząco poprawia elastyczność szablonów.
Jest to bardzo potężne narzędzie, wciąż szeroko stosowane przy budowaniu szablonów w plikach konfiguracyjnych.

Zapamiętaj: Metoda .format() pozwala na wielokrotne użycie tej samej zmiennej w tekście poprzez odwoływanie się do jej indeksu lub nazwy w klamrach.

imie = "Anna"
wiek = 22
tekst1 = "Cześć {}, masz {} lata.".format(imie, wiek)
tekst2 = "Osoba {0} ma {1} lat. {0} to super student.".format(imie, wiek)
print(tekst1)
print(tekst2)

Metoda format() została wprowadzona w Pythonie 3 jako elastyczna alternatywa dla operatora %, oferując nazywanie placeholders i wielokrotne użycie wartości. To w format() pojawiły się pierwsze zaawansowane specyfikatory formatu.

Zaletą format() jest możliwość odwoływania się do argumentów po nazwie, co jest przydatne przy internacjonalizacji. Metoda obsługuje również zaawansowane specyfikatory, takie jak formatowanie dat.

W wersji Pythona 3.6 zadebiutował rewolucyjny, najnowocześniejszy i obecnie domyślny sposób formatowania tekstu -- sformatowane literały łańcuchowe, czyli f-stringi.
Aby utworzyć f-string, wystarczy przed cudzysłowem otwierającym napis postawić literę f lub F, np. f"tekst".
Wewnątrz takiego łańcucha znaków możemy umieścić nawiasy klamrowe {}, wewnątrz których wpisujemy bezpośrednio nazwy zmiennych istniejących w naszym kodzie.
Python podczas wykonywania programu automatycznie odczyta wartości tych zmiennych i wstrzyknie je w odpowiednie miejsca.
Metoda ta jest niezwykle czytelna, krótka w zapisie i wolna od błędów związanych z kolejnością argumentów.

Zapamiętaj: F-stringi są nie tylko najkrótsze i najbardziej czytelne, ale również najszybszą metodą formatowania tekstu w Pythonie pod kątem wydajności.

imie = "Tomasz"
wiek = 28
komunikat = f"Student {imie} ma obecnie {wiek} lat."
print(komunikat)

F-stringi, wprowadzone w Pythonie 3.6, stanowią kwintesencję filozofii Pythona – prostotę, czytelność i wydajność. W przeciwieństwie do wcześniejszych metod są przetwarzane na etapie kompilacji kodu, co zapewnia przewagę wydajnościową.

Rewolucyjność f-stringów polega na bezpośrednim wstawianiu wyrażeń w tekście. Ta naturalność zapisu sprawia, że są obecnie standardem w nowoczesnym Pythonie, zalecanym przez oficjalną dokumentację jako główna metoda formatowania.

Ogromną zaletą i siłą f-stringów w Pythonie jest fakt, że wewnątrz nawiasów klamrowych {} możemy umieszczać nie tylko zwykłe zmienne, ale również dowolne poprawne wyrażenia.
Oznacza to, że bezpośrednio w tekście możemy wykonywać operacje matematyczne (np. dodawanie czy mnożenie zmiennych).
Co więcej, możemy tam również wywoływać wbudowane funkcje (np. len()) lub wywoływać metody na obiektach tekstowych (np. .upper()).
Cały ten kod zostanie zinterpretowany i wykonany dynamicznie w momencie tworzenia napisu przez interpreter Pythona.
Zapewnia to niesamowitą elastyczność i drastycznie zmniejsza ilość kodu pomocniczego.

Zapamiętaj: Choć w f-stringach można pisać zaawansowane wyrażenia, dbaj o czytelność kodu. Zbyt skomplikowane obliczenia lepiej wykonać w osobnej linii przed tekstem.

a = 5
b = 10
imie = "jan"
raport = f"Suma: {a + b}, Długość imienia: {len(imie)}, Wielkimi: {imie.upper()}"
print(raport)

Możliwość umieszczania dowolnych wyrażeń wewnątrz f-stringów otwiera drzwi do bardzo zwięzłego zapisu. Wyrażenia arytmetyczne, wywołania funkcji, a nawet operator warunkowy mogą być umieszczone bezpośrednio w tekście.

Wydajność f-stringów z wyrażeniami jest doskonała – są szybsze od format() i operatora %. W połączeniu z listami składanymi pozwalają na generowanie raportów w jednej linii. Zbyt skomplikowane wyrażenia lepiej jednak wyliczyć wcześniej.

F-stringi oferują bardzo bogate i eleganckie wsparcie dla zaawansowanego formatowania wyświetlanych danych liczbowych.
Po nazwie zmiennej wewnątrz klamer możemy postawić dwukropek :, po którym wpisujemy specyfikator formatu określający sposób prezentacji danej wartości.
Przykładowo, specyfikator :.2f nakazuje zaokrąglić i wyświetlić liczbę zmiennoprzecinkową z dokładnością do dokładnie dwóch miejsc po przecinku.
Z kolei specyfikator :05d uzupełni liczbę całkowitą zerami wiodącymi do łącznej szerokości pięciu znaków.
Pozwala to na łatwe i precyzyjne generowanie raportów finansowych, wskaźników postępu czy tabelarycznych podsumowań w konsoli.

Zapamiętaj: Formatowanie zaokrągla wartość wyłącznie na potrzeby wyświetlania w tekście. Oryginalna zmienna liczbowa zachowuje pełną precyzję matematyczną.

pi = 3.14159265
liczba = 42
raport = f"Pi: {pi:.2f}, Zera wiodące: {liczba:05d}"
print(raport)  # 'Pi: 3.14, Zera wiodące: 00042'

Formatowanie liczb w f-stringach to funkcja niezastąpiona w analizie danych. Specyfikatory :.2f, :05d, :,.2f, :.2% kontrolują wygląd wartości numerycznych. Ważne: formatowanie zaokrągla tylko do wyświetlenia, nie zmieniając oryginalnej wartości.

W praktyce biznesowej formatowanie z separatorem tysięcy i dwoma miejscami po przecinku jest standardem pieniężnym. F-stringi obsługują też system szesnastkowy, ósemkowy i binarny. Specyfikator procentowy mnoży przez 100 i dodaje znak %.

Wewnątrz łańcuchów znaków w Pythonie możemy umieszczać specjalne, niewidoczne znaki sterujące pracą terminala za pomocą ukośnika wstecznego \ (ang. backslash).
Znak ten tworzy tak zwaną sekwencję ucieczki (ang. escape sequence), która informuje interpreter o specjalnym znaczeniu kolejnej litery.
Najpopularniejszymi sekwencjami są \n, która wymusza przejście do nowej linii, oraz \t, która wstawia tabulator (wcięcie).
Jeśli chcemy wyświetlić fizyczny ukośnik wsteczny w tekście, musimy zapisać go podwójnie \\.
Sekwencje ucieczki pozwalają na pełną kontrolę nad strukturą i formatowaniem wyświetlanego tekstu.

Zapamiętaj: Sekwencje ucieczki działają w standardowych stringach. Jeśli chcesz je wyłączyć, użyj raw stringa (prefiks r przed cudzysłowem).

sciezka = "C:\\Uzytkownicy\\Jan"
tekst = "Linia 1\nLinia 2\tWcięcie"
print(sciezka)
print(tekst)

Sekwencje ucieczki w Pythonie pochodzą z języka C. Znak backslasha rozpoczyna sekwencję interpretowaną jako znak sterujący. Najczęściej używane to \n (nowa linia), \t (tabulacja), \\ (backslash).

Współczesne Pythony używają UTF-8, więc większość znaków można wpisać bezpośrednio. Znajomość sekwencji ucieczki jest jednak niezbędna przy danych binarnych. Raw stringi z prefiksem r wyłączają interpretację backslashy.

Łańcuchy znaków w Pythonie możemy bez problemu porównywać za pomocą standardowych operatorów porównania, takich jak ==, !=, <, >, <= oraz >=.
Porównywanie to odbywa się w porządku leksykograficznym (słownikowym) na podstawie wartości kodów ASCII/Unicode poszczególnych znaków w pamięci komputera.
Oznacza to, że Python porównuje znaki po kolei od lewej do prawej strony, decydując o wyniku na pierwszej różniącej się pozycji.
Warto pamiętać, że wielkie litery mają w tablicy ASCII mniejsze kody numeryczne niż małe litery (np. 'A' ma kod 65, a 'a' kod 97).
Z tego powodu napis 'Akademia' w domyślnym porównaniu będzie mniejszy niż napis 'akademia'.

Zapamiętaj: Porównywanie stringów jest ściśle wrażliwe na wielkość liter. Do bezpiecznych porównań leksykograficznych sprowadź oba teksty do małych liter za pomocą .lower().

tekst1 = "jablko"
tekst2 = "banan"
print(tekst1 == tekst2)  # False
print(tekst2 < tekst1)   # True ('b' ma mniejszy kod niż 'j')
print("A" < "a")        # True (65 < 97)

Porównywanie stringów w Pythonie opiera się na porządku leksykograficznym według kodów Unicode. Python porównuje znak po znaku, a o wyniku decyduje pierwsza para różniących się znaków.

W praktyce często potrzebne jest porównywanie bez uwzględniania wielkości liter przez lower(). Dla sortowania polskich nazwisk konieczne jest użycie modułu locale lub zewnętrznych bibliotek.

Jednym z najbardziej spektakularnych i popularnych skrótów składniowych w języku Python jest odwracanie napisów za pomocą wycinka z ujemnym krokiem.
Zapis s[::-1] nakazuje Pythonowi wycięcie całego napisu od samego końca do początku (ponieważ krok wynosi -1).
Brak podanych wartości start oraz stop automatycznie dostosowuje granice wycinania do kierunku wstecznego, obejmując cały łańcuch znaków.
Operacja ta wykonuje się niesamowicie szybko, ponieważ cała pętla odwracająca znaki realizowana jest bezpośrednio w zoptymalizowanym kodzie kompilowanym C.
Jest to domyślny, zalecany i najbardziej pythonowy sposób na odwrócenie dowolnego tekstu w locie.

Zapamiętaj: Odwrócenie za pomocą s[::-1] tworzy nowy string w pamięci. Jest to operacja bardzo wydajna pod kątem czasu wykonania.

slowo = "kajak"
odwrocone = slowo[::-1]
print(odwrocone)  # 'kajak'
komunikat = "Python"[::-1]
print(komunikat)  # 'nohtyP'

Odwracanie napisu s[::-1] to jeden z najbardziej eleganckich idiomów Pythona, często pojawiający się na rozmowach kwalifikacyjnych. Operacja jest zaimplementowana w kodzie C, co zapewnia maksymalną wydajność.

W algorytmice odwracanie tekstu jest podstawą bardziej złożonych operacji. S[::-1] tworzy nowy obiekt, co ma znaczenie przy dużych napisach. Można wtedy użyć reversed(), które zwraca iterator.

Dzięki temu, że typ str w Pythonie jest niemutowalny, interpreter może zastosować zaawansowaną optymalizację pamięciową zwaną stałym osadzaniem łańcuchów (ang. String Interning).
Mechanizm ten polega na tym, że jeśli w kodzie programu tworzymy kilka identycznych, krótkich napisów dosłownych, Python nie alokuje dla nich osobnych obszarów w pamięci.
Zamiast tego tworzy w pamięci RAM tylko jeden fizyczny obiekt tekstowy, a wszystkie zmienne o tej samej wartości kieruje pod ten sam adres pamięci.
Pozwala to na drastyczne zaoszczędzenie pamięci operacyjnej w dużych aplikacjach przetwarzających bazy tekstowe.
Ułatwia to również błyskawiczne porównywanie tożsamości obiektów za pomocą operatora is.

Zapamiętaj: String interning działa automatycznie pod maską Pythona dla napisów składających się z liter, cyfr i podkreśleń o ograniczonej długości.

a = "program"
b = "program"
print(a == b)  # True (porównanie wartości)
print(a is b)  # True (tożsamość - ten sam adres w pamięci!)

String Interning to mechanizm optymalizacyjny współdzielący identyczne literały tekstowe w pamięci. Fizycznie w RAM powstaje tylko jeden obiekt dla identycznych napisów dosłownych. Python stosuje to dla krótkich napisów.

Wpływ String Interning na wydajność jest dwojaki: zmniejsza zużycie pamięci i przyspiesza porównania is. W codziennej pracy zawsze używaj == do porównywania wartości, a is tylko do sprawdzania tożsamości obiektów.

Podczas pracy ze ścieżkami do plików w systemie Windows lub z wyrażeniami regularnymi (regex), ukośniki wsteczne \ stają się dużym problemem, ponieważ Python traktuje je jako start sekwencji ucieczki.
Aby całkowicie wyłączyć interpretowanie backslasha jako znaku specjalnego, wprowadzono surowe łańcuchy znaków (ang. raw strings).
Tworzy się je przez dodanie litery r lub R bezpośrednio przed cudzysłowem otwierającym napis, np. r"tekst".
W takim surowym napisie sekwencje takie jak \n czy \t są traktowane jako dwa zwykłe, fizyczne znaki -- ukośnik i litera.
Drastycznie ułatwia to pisanie przejrzystego kodu i eliminuje potrzebę ręcznego podwajania ukośników.

Zapamiętaj: Raw stringi są nieodzowne przy pracy z modułem re (wyrażenia regularne) oraz przy definiowaniu ścieżek do folderów w systemie operacyjnym Windows.

normalny = "C:\\nowy\\folder"  # Wymaga podwójnych backslashy
surowy = r"C:\nowy\folder"    # Czysty i czytelny zapis
print(normalny)
print(surowy)

Raw stringi z prefiksem r są niezastąpione przy ścieżkach Windows i wyrażeniach regularnych. Backslash w standardowym stringu rozpoczyna sekwencję ucieczki, co zmusza do podwajania. Raw string automatycznie to wyłącza.

W regex raw stringi są wręcz wymagane, ponieważ wzorce intensywnie używają backslashy. Raw string nie może kończyć się pojedynczym backslashem, ponieważ spowoduje błąd składni.

Metody czyszczące brzegi tekstu -- .strip(), .lstrip() oraz .rstrip() -- posiadają ukrytą, bardzo potężną funkcjonalność, o której często zapominają nowicjusze.
Jako opcjonalny argument możemy przekazać do nich ciąg znaków, który definiuje zestaw konkretnych symboli do usunięcia z krańców tekstu.
Python będzie usuwał podane znaki z brzegów napisu tak długo, jak długo będzie na nie napotykał, aż do momentu trafienia na pierwszy znak spoza zestawu.
Należy pamiętać, że argument ten nie jest traktowany jako spójna fraza, lecz jako zbiór pojedynczych znaków do wycięcia.
Pozwala to na bardzo wygodne usuwanie nawiasów, kropek czy znaków specjalnych z pobieranych ciągów.

Zapamiętaj: Kolejność znaków w argumencie strip() nie ma znaczenia. Przekazanie strip('.,!') usunie wszelkie kropki, przecinki i wykrzykniki z krańców tekstu.

url = "www.python.org..."
czysty = url.strip("w.")  # Usunie 'www.' oraz '...'
tekst = "[LOG]: Błąd systemu!"
komunikat = tekst.strip("[]!")  # Usunie '[', ']' i '!' z krańców
print(czysty, "|", komunikat)

Przekazanie zestawu znaków do strip() znacznie rozszerza jej funkcjonalność. Argument jest zbiorem pojedynczych symboli do usunięcia z obu końców, kontynuując aż do napotkania znaku spoza zbioru.

W praktyce strip() z argumentem czyści dane z formatowania, nawiasów czy cudzysłowu. W połączeniu z lstrip() i rstrip() daje pełną kontrolę nad czyszczeniem danych z systemów legacy.

Metoda .split() posiada bardzo użyteczny, opcjonalny parametr o nazwie maxsplit, który pozwala na precyzyjne ograniczenie maksymalnej liczby podziałów tekstu.
Domyślnie Python wykonuje wszystkie możliwe podziały w tekście od lewej do prawej strony.
Zdefiniowanie parametru maxsplit na wartość N nakazuje wykonanie dokładnie N cięć tekstu, po czym cały pozostały fragment tekstu jest umieszczany bez podziału jako ostatni element listy.
Jest to niezwykle przydatne przy analizowaniu logów systemowych czy nagłówków wiadomości, gdzie chcemy wyodrębnić tylko kluczowe parametry z początku linii, pozostawiając resztę opisu w nienaruszonej formie.

Zapamiętaj: Jeśli chcesz dzielić tekst od prawej strony, użyj bliźniaczej metody .rsplit(), która w połączeniu z maxsplit zaczyna podział od końca napisu.

linia = "ERROR:BazaDanych:Nie można połączyć z hostem lokalnym"
czesci = linia.split(":", maxsplit=2)
print(czesci)  # ['ERROR', 'BazaDanych', 'Nie można połączyć z hostem lokalnym']

Parametr maxsplit w split() kontroluje liczbę podziałów, co jest przydatne przy parsowaniu danych o znanej strukturze. Na przykład w logach serwerowych maxsplit=3 wyodrębnia strukturę bez utraty reszty.

Rsplit() dzieli od prawej strony – z maxsplit=1 oddziela ostatni element od reszty, np. przy parsowaniu rozszerzeń plików. Zrozumienie różnicy pozwala na precyzyjniejszy kod.

Metoda .join() jest uniwersalnym i potężnym narzędziem pozwalającym na elastyczne scalanie kolekcji tekstowych przy użyciu różnorodnych separatorów.
Jako separator wywołujący metodę możemy zdefiniować dowolny łańcuch znaków, w tym znaki specjalne, takie jak nowa linia \n czy tabulator \t.
Umożliwia to błyskawiczne generowanie przejrzystych wydruków pionowych, sformatowanych wierszy tabelarycznych czy skomplikowanych ścieżek systemowych.
Ponieważ .join() jest niesamowicie zoptymalizowany, potrafi scalić nawet setki tysięcy słów w ułamku sekundy, co czyni go nieodzownym elementem zaawansowanego przetwarzania tekstów.

Zapamiętaj: Pamiętaj o wydajności: używanie .join() alokuje pamięć na wynikowy string tylko raz, podczas gdy wielokrotne użycie '+' alokuje pamięć w każdym kroku.

elementy = ["Rozdział 1", "Wstęp", "Teoria"]
pionowo = "\n".join(elementy)
print(pionowo)

Join() to najwydajniejszy sposób łączenia kolekcji stringów, przewyższający operator + kilkudziesięciokrotnie. Alokuje pamięć raz, podczas gdy + tworzy nowy obiekt przy każdym łączeniu.

Wybór separatora w join() ma kluczowe znaczenie: ″″ scala bezpośrednio, ″, ″ tworzy listę, ″\n″ dzieli na linie. Ta elastyczność czyni join() niezastąpionym przy generowaniu CSV i raportów.

Poza popularnymi metodami walidacyjnymi, Python oferuje zestaw specjalistycznych metod pozwalających na precyzyjną ocenę struktury tekstu.
Metoda .istitle() weryfikuje, czy badany łańcuch znaków jest zapisany w stylu tytułowym (każde słowo rozpoczyna się wielką literą, po której następują małe litery).
Metoda .isspace() sprawdza, czy napis składa się wyłącznie z tak zwanych białych znaków (spacje, tabulatory, znaki nowej linii) i nie zawiera żadnych liter ani cyfr.
Jest to niezmiernie przydatne do wykrywania pustych wpisów w formularzach, gdzie użytkownik kliknął wyłącznie spację w polu tekstowym.

Zapamiętaj: Zawsze używaj .isspace(), aby upewnić się, że wejście od użytkownika nie jest wyłącznie ciągiem spacji i zawiera faktyczne znaki.

pusty = "   \n  \t  "
tytul = "Wielki Podręcznik Pythona"
print(pusty.isspace())   # True
print(tytul.istitle())   # True

Metody istitle() i isspace() rozszerzają walidację Pythona. Istitle() sprawdza konwencję tytułową, co jest przydatne przy nagłówkach, ale ma ograniczenia przy apostrofach.

Isspace() to najprostszy sposób wykrycia, czy pole zawiera tylko białe znaki. W przeciwieństwie do porównania z pustym stringiem wykrywa spacje i tabulatory. Ważne przy walidacji formularzy.

F-stringi w Pythonie posiadają wbudowane mechanizmy pozycjonowania i wyrównywania tekstu wewnątrz zdefiniowanego pola o stałej szerokości.
Po nazwie zmiennej i dwukropku możemy użyć jednego z trzech znaków wyrównania: < dla wyrównania do lewej, > dla wyrównania do prawej oraz ^ dla pozycjonowania na środku.
Po znaku wyrównania wpisujemy liczbę całkowitą określającą całkowitą szerokość pola w znakach, np. f"{x:>10}".
Jeśli chcemy zmienić domyślny znak wypełniający (spację), możemy wpisać własny symbol bezpośrednio przed operatorem wyrównania.
Pozwala to na niesamowicie łatwe generowanie profesjonalnych tabel tekstowych w konsoli.

Zapamiętaj: Możesz użyć dowolnego pojedynczego znaku (np. '.', '-', '*') jako wypełniacza pola przed operatorem wyrównania.

nazwa = "Chleb"
cena = 5.50
print(f"{nazwa:<15} kosztuje {cena:>8.2f} zł")
print(f"{nazwa:-^20}")

Wyrównywanie w f-stringach znacznie poprawia jakość raportów. Składnia :<, :>, :^ jest intuicyjna, a własny znak wypełniający pozwala na estetyczne wydruki.

W praktyce formatowanie z wyrównaniem jest niezastąpione przy tabelach przestawnych i raportach finansowych. Stała szerokość kolumn i równomierne odstępy dają profesjonalny wygląd.

Interpreter języka Python traktuje kod zawarty w nawiasach klamrowych {} f-stringów jako pełnoprawne wyrażenie, które należy wyliczyć dynamicznie podczas wykonywania programu.
Oznacza to, że możemy tam umieszczać nie tylko proste zmienne, ale również złożone wyrażenia logiczne, warunki, a nawet wywoływać zagnieżdżone funkcje.
Zapewnia to niesamowite możliwości skracania zapisu i ułatwia szybkie generowanie komunikatów o statusie aplikacji bez pisania osobnych bloków warunkowych.
Należy jednak zawsze pamiętać o zachowaniu czytelności kodu i unikać wstrzykiwania zbyt skomplikowanej logiki biznesowej bezpośrednio w tekst.

Zapamiętaj: Możesz nawet używać operatorów logicznych i instrukcji warunkowych wewnątrz f-stringa za pomocą trójargumentowego operatora warunkowego (ternary operator).

punkty = 75
komunikat = f"Wynik testu: {punkty} pkt - {'ZALICZONY' if punkty >= 50 else 'NIEZALICZONY'}"
print(komunikat)

Wyrażenia warunkowe wewnątrz f-stringów pozwalają na dynamiczne komunikaty bez rozbijania tekstu. Operator trójargumentowy w f-stringu czyni kod bardziej zwartym, ale przy złożonych logikach lepiej użyć tradycyjnego if-else.

Wydajność f-stringów z wyrażeniami jest doskonała – interpreter kompiluje je do zoptymalizowanego kodu bajtowego. Nadmierne komplikowanie utrudnia jednak debugowanie.

Napiszmy kompletny, użyteczny program w Pythonie, który służy jako dynamiczny analizator dowolnego tekstu wprowadzonego przez użytkownika.
Program pobiera ciąg znaków, po czym precyzyjnie oblicza: łączną liczbę znaków (ze spacjami), liczbę znaków bez białych spacji, orientacyjną liczbę słów oraz zdań.
Do zliczenia słów wykorzystamy metodę .split(), która automatycznie radzi sobie z wielokrotnymi spacjami.
Do wyznaczenia liczby zdań skorzystamy z metody .count('.'), szukając kropek kończących myśli.
Taki program jest doskonałą ilustracją praktycznego połączenia wielu poznanych metod tekstowych w jeden, funkcjonalny skrypt.

Zapamiętaj: Ten prosty skrypt analizujący tekst może być z powodzeniem wykorzystany jako baza do pisania wtyczek zliczających słowa w edytorach tekstu.

tekst = "Python jest wspaniały. Uczymy się jego metod. To proste."
znaki = len(tekst)
znaki_bez_spacji = len(tekst.replace(" ", ""))
slowa = len(tekst.split())
zdania = tekst.count(".")
print(f"Znaki: {znaki}\nBez spacji: {znaki_bez_spacji}\nSłowa: {slowa}\nZdania: {zdania}")

Prosty analizator tekstu ilustruje praktyczne łączenie metod tekstowych. Len(), replace(), split() i count() realizują złożone analizy w kilku liniach kodu. Taki program może być podstawą analizy sentymentu.

W produkcji podobne analizatory monitorują wiadomości i analizują częstotliwość słów. Rozszerzenie o zliczanie znaków interpunkcyjnych to naturalny kierunek rozwoju.

Walidacja formatu adresu e-mail to jedno z najbardziej klasycznych zadań w aplikacjach webowych i bazodanowych.
Napiszmy kompletny program, który sprawdza podstawową strukturę adresu e-mail wprowadzonego przez użytkownika bez używania skomplikowanych wyrażeń regularnych.
Wykorzystamy w tym celu proste metody tekstowe: upewnimy się, że w adresie występuje dokładnie jeden znak małpki @ za pomocą metody .count().
Sprawdzimy, czy po małpce występuje chociaż jedna kropka . za pomocą metody .find() oraz wycinków.
Na koniec zweryfikujemy, czy adres nie zaczyna się ani nie kończy spacjami, oraz czy ma odpowiednią długość.

Zapamiętaj: Choć pełna walidacja e-mail wymaga wyrażeń regularnych, ten prosty walidator oparty na metodach str pozwala na błyskawiczne odrzucenie ponad 95% niepoprawnych adresów.

email = " student@uczelnia.edu.pl ".strip()
if email.count("@") == 1 and "." in email.split("@")[1]:
    print(f"Adres '{email}' jest poprawny.")
else:
    print(f"Błędny format adresu e-mail.")

Walidacja e-mail podstawowymi metodami tekstowymi łączy różne techniki weryfikacyjne. Sprawdzenie @ i kropki w domenie odrzuca większość błędnych adresów. Strip() zapobiega akceptacji adresów ze spacjami.

W produkcji walidacja e-mail jest wieloetapowa: format, walidacja serwerowa, wysłanie weryfikacji. Zrozumienie tego procesu jest ważne dla każdego programisty webowego.

W raportowaniu biznesowym kluczowe jest przedstawienie surowych danych w postaci czytelnej, dobrze sformatowanej tabeli tekstowej w konsoli.
Napiszmy program, który pobiera listę produktów wraz z ich cenami i stanem magazynowym, po czym generuje przejrzysty raport sprzedaży.
Wykorzystamy do tego metody .ljust() oraz .rjust(), które zagwarantują stałą szerokość kolumn niezależnie od długości nazw produktów.
Ceny zostaną sformatowane z precyzją dwóch miejsc po przecinku za pomocą f-stringa.
Taki skrypt pozwala na błyskawiczne przekształcenie surowych krotek w estetyczny, czytelny wydruk biznesowy.

Zapamiętaj: Stała szerokość kolumn w raportach tekstowych ułatwia szybkie skanowanie danych wzrokiem i wygląda bardzo profesjonalnie.

produkty = [("Biurko", 350.00), ("Krzesło", 120.50), ("Lampa", 45.00)]
print(f"{'Produkt':<15} | {'Cena':>10}")
print("-" * 30)
for p, c in produkty:
    print(f"{p:<15} | {c:>10.2f} zł")

Formatowanie raportu sprzedaży łączy listy, f-stringi i metody wyrównujące. Generowanie tabeli z nagłówkiem i wierszami wymaga precyzyjnej kontroli szerokości kolumn. Pętla for do generowania wierszy to realny wzorzec projektowy.

Raporty w konsoli są wciąż popularne w środowiskach serwerowych. Doświadczeni programiści tworzą własne funkcje pomocnicze do generowania tabel.

Pierwsze ćwiczenie praktyczne polega na napisaniu prostego programu, który pobiera od użytkownika jedno słowo i wyświetla je w odwrotnej kolejności.
Zadanie to ma na celu utrwalenie wiedzy na temat wycinków sekwencji oraz ujemnego kroku.
Student powinien zadeklarować zmienną tekstową za pomocą funkcji input(), a następnie skorzystać z optymalnego zapisu wycinka s[::-1].
Wynik należy wyświetlić w konsoli w postaci czytelnego komunikatu.
To ćwiczenie uświadamia, jak zwięzły i wydajny może być kod w Pythonie w porównaniu do tradycyjnych języków programowania.

Zapamiętaj: Spróbuj napisać to ćwiczenie w jednej linii kodu, łącząc pobieranie input() bezpośrednio z wycinaniem i funkcją print().

slowo = input("Podaj słowo do odwrócenia: ")
odwrocone = slowo[::-1]
print(f"Słowo odwrócone: {odwrocone}")

Odwracanie słowa to pierwszy krok do zrozumienia potęgi wycinków. S[::-1] jest tak zwięzły, że używa się go jako przykładu elegancji Pythona. W Javie czy C++ wymagałoby pętli.

W rzeczywistych projektach odwracanie tekstu stosuje się w kryptografii i grach. Łączenie input() z wycinkami w jednej linii to cecha doświadczonych programistów.

Palindrom to słowo lub całe zdanie, które brzmi identycznie czytane od lewej do prawej, jak i od prawej do lewej (np. 'kajak' czy 'potop').
Kolejne ćwiczenie polega na napisaniu programu sprawdzającego, czy podane przez użytkownika słowo jest palindromem.
Student musi pobrać napis, sprowadzić go do małych liter za pomocą .lower() w celu zignorowania wielkości liter, a następnie porównać go z jego odwróconą wersją s[::-1].
Jeśli oba napisy są identyczne, program wyświetla komunikat potwierdzający, w przeciwnym razie zaprzecza.
To ćwiczenie doskonale uczy bezpiecznego porównywania danych.

Zapamiętaj: Aby program działał również dla całych zdań (np. 'Kobyła ma mały bok'), przed porównaniem usuń z tekstu wszystkie spacje za pomocą metody .replace(' ', '').

tekst = input("Podaj słowo: ").lower().replace(" ", "")
if tekst == tekst[::-1]:
    print("To jest palindrom!")
else:
    print("To nie jest palindrom.")

Sprawdzanie palindromów to klasyczne zadanie algorytmiczne. Lower(), replace() i s[::-1] dają kompletne rozwiązanie w kilku liniach. Zadanie pojawia się na rozmowach kwalifikacyjnych.

Warto rozszerzyć o palindromy zdań z usuwaniem interpunkcji przez listę składaną i join(). To rozwija kreatywne łączenie technik przetwarzania tekstu.

W aplikacjach społecznościowych i forach internetowych kluczowe jest automatyczne filtrowanie wulgaryzmów lub niedozwolonych fraz.
Napisz program, który pobiera od użytkownika zdanie, a następnie wyszukuje w nim zakazane słowo i zastępuje je gwiazdkami o tej samej długości.
Do wykonania zadania student powinien użyć metody .replace() oraz operatora powtarzania znaków *.
Dzięki temu długość maski z gwiazdek będzie dokładnie odpowiadała długości cenzurowanego słowa.
Jest to znakomity trening łączenia metod tekstowych z dynamicznym generowaniem znaków.

Zapamiętaj: Użycie mnożenia znaków '*' pozwala na wygenerowanie maski (np. '*' * len(slowo)), co jest o wiele bardziej eleganckie niż stała liczba gwiazdek.

zdanie = "Ten skrypt PHP jest bardzo powolny!"
zakazane = "PHP"
cenzura = "*" * len(zakazane)
nowe_zdanie = zdanie.replace(zakazane, cenzura)
print(nowe_zdanie)

Cenzurowanie to praktyczny przykład replace() w moderacji treści. Maska gwiazdek z operatorem * o długości słowa zachowuje proporcje tekstu.

W systemach produkcyjnych cenzurowanie jest częścią moderatorów z listą w bazie danych. Ważna jest wydajność replace() dzięki optymalizacji w C.

Napisz program, który zlicza, ile samogłosek (a, e, i, o, u, y) występuje w podanym przez użytkownika tekście.
Zadanie to wymaga połączenia wiedzy na temat pętli for, instrukcji warunkowych oraz sprawdzania zawartości przy użyciu operatora in.
Student powinien przeiterować pętlą po każdym znaku w tekście, sprawdzając, czy dany znak (sprowadzony do małej litery) znajduje się w zbiorze samogłosek.
Jeśli tak, należy zwiększyć wartość licznika o 1.
Ćwiczenie to doskonale łączy przetwarzanie sekwencji tekstowych z podstawowymi strukturami sterującymi w języku Python.

Zapamiętaj: Zdefiniowanie samogłosek jako jednego stringa 'aeiouy' pozwala na szybkie i czytelne sprawdzenie warunku: 'znak in samogloski'.

tekst = input("Podaj tekst: ").lower()
samogloski = "aeiouy"
licznik = 0
for znak in tekst:
    if znak in samogloski:
        licznik += 1
print(f"Liczba samogłosek: {licznik}")

Liczenie samogłosek wprowadza iterację z akumulacją. Pętla for z operatorem in to fundament Python pojawiający się wszędzie. Stały string samogłosek to prosty, skuteczny wzorzec.

Podobne techniki zliczają kategorie znaków w analizie danych. Rozszerzeniem może być jednoczesne zliczanie samogłosek i spółgłosek. Zadanie uczy normalizacji wielkości liter.

Łańcuchy znaków (typ str) są jednym z najważniejszych i najczęściej używanych typów danych w Pythonie.
Poznaliśmy bogaty zestaw wbudowanych metod, które pozwalają na niemal dowolne transformowanie, wyszukiwanie oraz walidowanie informacji tekstowych.
Kluczowe jest ciągłe pamiętanie o zasadzie niemutowalności -- żadna metoda nie modyfikuje napisu w miejscu, zawsze zwracany jest nowy obiekt.
Poniższa tabela stanowi podręczne zestawienie najważniejszych metod tekstowych, ich parametrów oraz zwracanych wartości.
Znajomość tych metod pozwala na swobodne pisanie zaawansowanych programów przetwarzających dane tekstowe.

Zapamiętaj: Zawsze sprawdzaj dokumentację Pythona za pomocą funkcji help(str) w konsoli REPL, aby poznać wszystkie dostępne metody i ich szczegółowe parametry.

# Tabela najważniejszych metod tekstowych:
# .upper() / .lower()   - Zmiana wielkości liter
# .strip()               - Usuwanie białych znaków z krańców
# .split() / .join()     - Rozbijanie i scalanie napisów
# .replace(stary, nowy)  - Zamiana fragmentów tekstu
# .find() / .index()     - Wyszukiwanie pozycji podciągu
# .startswith()/.endswith() - Sprawdzanie prefiksu/sufiksu
# .isdigit()/.isalpha()  - Weryfikacja typu zawartości

Podsumowanie metod stringów to całościowe spojrzenie. Metody transformacyjne zwracają napisy, wyszukiwania liczby, logiczne wartości boolowskie. Wybór metody do zadania to cecha doświadczonego programisty.

Help(str) w REPL pokazuje pełną listę metod. Korzystanie z dokumentacji to nawyk profesjonalistów. W dalszej części kursu poznamy bogatsze zestawy metod.

Część siódma naszego kursu była w całości poświęcona zaawansowanemu przetwarzaniu informacji tekstowych w języku Python.
Szczegółowo przeanalizowaliśmy strukturę łańcuchów znaków jako uporządkowanych, niezmiennych sekwencji.
Poznaliśmy mechanizmy indeksowania dodatniego i ujemnego, które pozwalają na natychmiastowy dostęp do poszczególnych znaków w tekście.
Nauczyliśmy się precyzyjnie wycinać fragmenty tekstu (slicing) z użyciem kroku dodatniego i ujemnego.
Na koniec przeanalizowaliśmy najnowocześniejsze techniki dynamicznego formatowania tekstu za pomocą f-stringów oraz poznaliśmy mechanizmy optymalizacji String Interning.

Zapamiętaj: Opanowanie pracy na łańcuchach znaków to fundament, bez którego niemożliwe jest przetwarzanie baz danych, budowanie interfejsów API czy parsowanie plików.

# Kluczowe pojęcia części 7:
# 1. str jako niezmienna (immutable) sekwencja znaków
# 2. Indeksowanie s[0] oraz ujemne s[-1]
# 3. Wycinki s[start:stop:krok] oraz odwracanie s[::-1]
# 4. Wbudowane metody: .split(), .join(), .replace(), .strip()
# 5. Nowoczesne, szybkie i czytelne f-stringi f"..."

Część siódma była kompendium łańcuchów znaków. Od indeksowania przez wycinki po f-stringi – każdy temat ma zastosowanie w codziennej pracy. Kluczowe jest zrozumienie niemutowalności.

Wiedza będzie wykorzystywana przy listach, plikach, bazach danych i API. Umiejętność przetwarzania tekstu to kluczowa kompetencja programisty. Zachęcam do eksperymentów.

W następnej części kursu wejdziemy w świat zaawansowanych struktur danych, rozpoczynając od list (typ list).
Listy to uporządkowane, mutowalne kolekcje, które stanowią fundament dynamicznego programowania w Pythonie.
Nauczymy się tworzyć listy, modyfikować ich elementy w locie, sortować dane na wiele sposobów oraz efektywnie je kopiować.
Poznamy również genialną, wysoce wydajną składnię list składanych (ang. list comprehension), która pozwala na generowanie nowych list w zwięzłej, jednoliniowej formie.
Wiedza ta otworzy przed Tobą drzwi do swobodnego operowania na dużych zbiorach danych w pamięci aplikacji.

Zapamiętaj: Przygotuj się na wejście w świat dynamicznych kolekcji. Listy w Pythonie są niezwykle elastyczne i stanowią jedno z najpopularniejszych narzędzi każdego programisty.

# W części 8 poznamy m.in.:
# - Tworzenie i modyfikację list: .append(), .insert(), .extend()
# - Usuwanie elementów: .remove(), .pop(), del
# - Sortowanie list: .sort() vs sorted()
# - Kopiowanie płytkie (shallow) i głębokie (deep copy)
# - Genialną składnię list składanych (list comprehension)

Zapowiedź części ósmej wprowadza listy – pierwszy mutowalny typ kolekcyjny. Listy pozwalają na modyfikację w miejscu, co otwiera nowe możliwości. Listy składane to jeden z najeleganckich elementów Pythona.

Przed częścią ósmą warto utrwalić wycinki i indeksowanie. Zrozumienie append(), extend() i insert() będzie kluczowe. Listy to fundament zaawansowanych struktur danych.