Python · Синтаксис · Початковий рівень

Методи рядків та f-strings

10 завдань

Вивчіть найважливіші вбудовані методи рядків і форматування через f-strings.

Короткий вступ до теми та пояснення перед вправами (вправи нижче):

Методи рядків

#
Рядки в Python — це незмінні (immutable) послідовності символів. Кожен метод рядка повертає **новий** рядок, оригінал залишається незмінним. ## Зміна регістру ```python text = "hello world" print(text.upper()) # "HELLO WORLD" print(text.lower()) # "hello world" print(text.capitalize()) # "Hello world" print(text.title()) # "Hello World" print(text.swapcase()) # "HELLO WORLD" ``` ## Видалення пробілів ```python s = " hello " print(s.strip()) # "hello" — з обох сторін print(s.lstrip()) # "hello " — тільки зліва print(s.rstrip()) # " hello" — тільки справа ``` `strip()` — найпоширеніший спосіб очистити введення користувача. ## Пошук і перевірка ```python s = "Python is great" print(s.find("is")) # 7 — індекс першого входження, -1 якщо не знайдено print(s.index("is")) # 7 — те саме, але кидає ValueError якщо не знайдено print(s.count("t")) # 2 print(s.startswith("Py")) # True print(s.endswith("eat")) # True print("123".isdigit()) # True print("abc".isalpha()) # True print("abc123".isalnum()) # True ``` ## Заміна і розбиття ```python s = "one two three" print(s.replace("two", "2")) # "one 2 three" print(s.split()) # ["one", "two", "three"] print(s.split(" ", maxsplit=1)) # ["one", "two three"] ``` `split()` без аргументів розбиває по будь-яких пробілах і видаляє порожні елементи. ## Об'єднання ```python words = ["one", "two", "three"] print(", ".join(words)) # "one, two, three" print("-".join(words)) # "one-two-three" print("".join(words)) # "onetwothree" ``` `join` — це зворотній до `split`: завжди викликається на **роздільнику**, а не на списку. ## Вирівнювання та заповнення ```python s = "hello" print(s.ljust(10)) # "hello " print(s.rjust(10)) # " hello" print(s.center(11, "-")) # "---hello---" print("42".zfill(5)) # "00042" ``` ## Головне правило Оскільки рядки незмінні, потрібно **привласнювати** результат: ```python name = " Alice " name = name.strip() # правильно name.strip() # нічого не відбувається — результат відкидається ```

f-strings

#
f-strings (форматовані рядкові літерали) — це сучасний і читабельний спосіб вставляти значення та вирази безпосередньо в рядки. Вони швидші за `%`-форматування і `.format()`. ## Базовий синтаксис ```python name = "Alice" age = 30 print(f"Hello, {name}! You are {age} years old.") # Hello, Alice! You are 30 years old. ``` Всередині `{}` можна вставляти будь-яку змінну або вираз: ```python a, b = 7, 3 print(f"{a} + {b} = {a + b}") # 7 + 3 = 10 print(f"{'hello'.upper()}") # HELLO ``` ## Форматування чисел ```python price = 9.5 pi = 3.14159 score = 0.876 print(f"{price:.2f}") # 9.50 — 2 знаки після коми print(f"{pi:.4f}") # 3.1416 — 4 знаки після коми print(f"{score:.1%}") # 87.6% — відсоток print(f"{1000000:,}") # 1,000,000 — роздільник тисяч print(f"{42:08d}") # 00000042 — ціле з нулями print(f"{42:>10}") # 42 — вирівнювання праворуч print(f"{42:<10}") # 42 — вирівнювання ліворуч print(f"{42:^10}") # 42 — по центру ``` ## Налагодження з `=` ```python x = 42 items = [1, 2, 3] print(f"{x=}") # x=42 print(f"{items=}") # items=[1, 2, 3] print(f"{len(items)=}") # len(items)=3 ``` Специфікатор `=` виводить і сам вираз, і його значення — ідеально для швидкого налагодження. ## Багаторядкові f-strings ```python name = "Bob" total = 123.45 message = ( f"Підсумок замовлення\n" f"Клієнт: {name}\n" f"Сума: ${total:.2f}" ) print(message) # Підсумок замовлення # Клієнт: Bob # Сума: $123.45 ``` ## Практичний приклад ```python def format_report(name, score, passed): status = "PASS" if passed else "FAIL" return f"[{status}] {name}: {score:.1f}/100" print(format_report("Alice", 87.5, True)) # [PASS] Alice: 87.5/100 print(format_report("Bob", 45.0, False)) # [FAIL] Bob: 45.0/100 ```

Довідник: методи рядків та f-strings

#
## Методи рядків | Метод | Що робить | Приклад | |---|---|---| | `s.upper()` | ВСЕ ВЕЛИКИМИ | `"hi".upper()` → `"HI"` | | `s.lower()` | всі малі | `"HI".lower()` → `"hi"` | | `s.capitalize()` | Перша велика | `"hi".capitalize()` → `"Hi"` | | `s.title()` | Кожне Слово З Великої | `"hi there".title()` → `"Hi There"` | | `s.strip()` | Видалити пробіли з обох сторін | `" hi ".strip()` → `"hi"` | | `s.lstrip()` / `s.rstrip()` | Тільки зліва / справа | — | | `s.replace(old, new)` | Замінити всі входження | `"aXa".replace("X","b")` → `"aba"` | | `s.split(sep)` | Розбити на список | `"a,b".split(",")` → `["a","b"]` | | `sep.join(lst)` | Об'єднати список у рядок | `",".join(["a","b"])` → `"a,b"` | | `s.find(sub)` | Індекс першого входження (-1 якщо немає) | `"abc".find("b")` → `1` | | `s.index(sub)` | Індекс (кидає ValueError) | — | | `s.count(sub)` | Підрахунок входжень | `"aaa".count("a")` → `3` | | `s.startswith(p)` | Починається з префіксу | `"abc".startswith("ab")` → `True` | | `s.endswith(p)` | Закінчується суфіксом | `"abc".endswith("bc")` → `True` | | `s.isdigit()` | Всі цифри | `"123".isdigit()` → `True` | | `s.isalpha()` | Всі літери | `"abc".isalpha()` → `True` | | `s.isalnum()` | Літери та цифри | — | | `s.ljust(n)` | Вирівняти ліворуч у ширині n | — | | `s.rjust(n)` | Вирівняти праворуч | — | | `s.center(n, c)` | По центру, заповнити c | — | | `s.zfill(n)` | Заповнити нулями до ширини n | `"7".zfill(3)` → `"007"` | ## Специфікатори формату f-string | Специфікатор | Значення | Приклад | |---|---|---| | `:.2f` | Дійсне, 2 знаки після коми | `f"{3.1:.2f}"` → `"3.10"` | | `:.1%` | Відсоток, 1 знак | `f"{0.875:.1%}"` → `"87.5%"` | | `:,` | Роздільник тисяч | `f"{1000:,}"` → `"1,000"` | | `:05d` | Ціле з нулями | `f"{7:05d}"` → `"00007"` | | `:>10` | Вирівнювання праворуч | `f"{'x':>10}"` → `" x"` | | `:<10` | Вирівнювання ліворуч | `f"{'x':<10}"` → `"x "` | | `:^10` | По центру | `f"{'x':^10}"` → `" x "` | | `=` | Налагодження: ім'я=значення | `f"{x=}"` → `"x=42"` | ## Поширені патерни ```python # Очистити введення користувача clean = user_input.strip().lower() # Перевірити і трансформувати if s.startswith("http"): s = s[len("http"):] # Зібрати речення зі списку слів sentence = " ".join(words) + "." # Форматування рядка таблиці row = f"{name:<20} {score:>6.1f} {'PASS' if score >= 60 else 'FAIL'}" ```

Вправи:

01

Title Case для імені

#
Напишіть функцію `format_name(name)`, яка приймає рядок і повертає його у форматі title case (кожне слово з великої літери). Приклад: `format_name("john doe")` → `"John Doe"`.
def format_name(name):
    pass


print(format_name("john doe"))      # John Doe
print(format_name("ALICE SMITH"))   # Alice Smith
Рішення 
def format_name(name):
    return name.title()


print(format_name("john doe"))      # John Doe
print(format_name("ALICE SMITH"))   # Alice Smith
02

Очистити введення

#
Напишіть функцію `clean(s)`, яка видаляє пробіли на початку/кінці рядка і переводить його у нижній регістр. Приклад: `clean(" Hello World ")` → `"hello world"`.
def clean(s):
    pass


print(clean("  Hello World  "))   # hello world
print(clean("  Python  "))        # python
Рішення 
def clean(s):
    return s.strip().lower()


print(clean("  Hello World  "))   # hello world
print(clean("  Python  "))        # python
03

Підрахунок слова

#
Напишіть функцію `count_word(text, word)`, яка підраховує, скільки разів `word` зустрічається у `text` (без урахування регістру). Приклад: `count_word("Apple apple APPLE", "apple")` → `3`.
def count_word(text, word):
    pass


print(count_word("Apple apple APPLE", "apple"))  # 3
print(count_word("cat cat dog cat", "cat"))      # 3
Рішення 
def count_word(text, word):
    return text.lower().count(word.lower())


print(count_word("Apple apple APPLE", "apple"))  # 3
print(count_word("cat cat dog cat", "cat"))      # 3
04

Цензура слова

#
Напишіть функцію `censor(text, word)`, яка замінює всі входження `word` у `text` зірочками тієї самої довжини. Приклад: `censor("I love cats", "cats")` → `"I love ****"`.
def censor(text, word):
    pass


print(censor("I love cats", "cats"))    # I love ****
print(censor("hello world", "world"))   # hello *****
Рішення 
def censor(text, word):
    return text.replace(word, "*" * len(word))


print(censor("I love cats", "cats"))    # I love ****
print(censor("hello world", "world"))   # hello *****
05

З'єднати через дефіс

#
Напишіть функцію `dashify(s)`, яка розбиває рядок на слова і з'єднує їх через дефіс. Приклад: `dashify("hello world foo")` → `"hello-world-foo"`.
def dashify(s):
    pass


print(dashify("hello world foo"))   # hello-world-foo
print(dashify("one two three"))     # one-two-three
Рішення 
def dashify(s):
    return "-".join(s.split())


print(dashify("hello world foo"))   # hello-world-foo
print(dashify("one two three"))     # one-two-three
06

Перевірити URL

#
Напишіть функцію `is_url(s)`, яка повертає `True`, якщо рядок починається з `"http://"` або `"https://"` і закінчується на `".com"`, `".org"` або `".net"`. Інакше повертає `False`.
def is_url(s):
    pass


print(is_url("https://example.com"))   # True
print(is_url("http://site.org"))       # True
print(is_url("ftp://bad.com"))         # False
print(is_url("https://no-ext.xyz"))    # False
Рішення 
def is_url(s):
    starts_ok = s.startswith("http://") or s.startswith("https://")
    ends_ok = s.endswith(".com") or s.endswith(".org") or s.endswith(".net")
    return starts_ok and ends_ok


# Коротший варіант з кортежами:
def is_url_v2(s):
    return s.startswith(("http://", "https://")) and s.endswith((".com", ".org", ".net"))


print(is_url("https://example.com"))   # True
print(is_url("ftp://bad.com"))         # False
07

Привітання через f-string

#
Напишіть функцію `greet(name, age)`, яка повертає привітання через f-string: `"Hello, {name}! You are {age} years old."`. Приклад: `greet("Alice", 25)` → `"Hello, Alice! You are 25 years old."`.
def greet(name, age):
    pass


print(greet("Alice", 25))   # Hello, Alice! You are 25 years old.
print(greet("Bob", 30))     # Hello, Bob! You are 30 years old.
Рішення 
def greet(name, age):
    return f"Hello, {name}! You are {age} years old."


print(greet("Alice", 25))   # Hello, Alice! You are 25 years old.
print(greet("Bob", 30))     # Hello, Bob! You are 30 years old.
08

Форматування ціни

#
Напишіть функцію `format_price(amount)`, яка форматує число як ціну з 2 знаками після коми та префіксом `$`. Приклад: `format_price(9.5)` → `"$9.50"`, `format_price(1000)` → `"$1,000.00"`.
def format_price(amount):
    pass


print(format_price(9.5))     # $9.50
print(format_price(1000))    # $1,000.00
print(format_price(0.99))    # $0.99
Рішення 
def format_price(amount):
    return f"${amount:,.2f}"


print(format_price(9.5))     # $9.50
print(format_price(1000))    # $1,000.00
print(format_price(0.99))    # $0.99
09

Безпечний пошук

#
Напишіть функцію `safe_find(text, sub)`, яка повертає індекс першого входження `sub` у `text`, або `-1` якщо не знайдено. НЕ використовуйте `.index()`. Приклад: `safe_find("hello", "ll")` → `2`, `safe_find("hello", "x")` → `-1`.
def safe_find(text, sub):
    pass


print(safe_find("hello", "ll"))   # 2
print(safe_find("hello", "x"))    # -1
print(safe_find("python", "on"))  # 4
Рішення 
def safe_find(text, sub):
    return text.find(sub)


print(safe_find("hello", "ll"))   # 2
print(safe_find("hello", "x"))    # -1
print(safe_find("python", "on"))  # 4
10

Текстовий прогрес-бар

#
Напишіть функцію `progress_bar(done, total, width=20)`, яка повертає текстовий прогрес-бар. Заповнення `"#"` для виконаної частини, `"."` для залишку. Приклад: `progress_bar(3, 10, 10)` → `"[###.......] 30%"`.
def progress_bar(done, total, width=20):
    pass


print(progress_bar(3, 10, 10))    # [###.......] 30%
print(progress_bar(0, 10, 10))    # [..........] 0%
print(progress_bar(10, 10, 10))   # [##########] 100%
Рішення 
def progress_bar(done, total, width=20):
    filled = int(width * done / total)
    bar = "#" * filled + "." * (width - filled)
    percent = done / total
    return f"[{bar}]{percent:>5.0%}"


print(progress_bar(3, 10, 10))    # [###.......] 30%
print(progress_bar(0, 10, 10))    # [..........] 0%
print(progress_bar(10, 10, 10))   # [##########] 100%