Рядок, який не можна змінити

У темі 03 ми домовились, що ім'я — це ярлик, наліплений на об'єкт, і що об'єкти бувають незмінні та змінювані. У темі 04 виявилось, що числа належать до першої групи: не можна «зробити з п'ятірки шістку», можна лише перевісити ярлик на іншу п'ятірку чи шістку. Тепер черга тексту. І тут та сама історія повторюється з несподіваною силою: рядок теж не змінюється ніколи, а кожна дія над ним створює новий об'єкт.

Наскрізний приклад у нас буде один — рядок із даними, який міг би прилетіти з файла чи з мережі:

Шістнадцять символів. З них ми навчимося витягати місто, назву товару й ціну, порахуємо, скільки це в байтах (спойлер: не шістнадцять), складемо з них охайний звіт — і побачимо щонайменше три способи зробити це неправильно.

01 / ЛапкиЯк народжується рядок

Рядок (string) — це літерал у лапках. Лапки бувають одинарні й подвійні, і різниці між ними немає жодної: 'кава' і "кава" дають однаковий об'єкт. Два варіанти існують рівно з однієї причини — щоб покласти всередину лапки іншого виду без зайвої мороки:

Якщо всередині потрібні саме такі лапки, якими рядок відкрито, їх екранують (escape) зворотним слешем: 'він сказав \'ні\''. Зворотний слеш вмикає спеціальне значення наступного символу — і саме тому сам слеш теж доводиться подвоювати.

Третій спосіб — потрійні лапки """…""". Усередині них можна вільно тиснути Enter: усі переходи на новий рядок збережуться в самому рядку. Це основний спосіб записати багаторядковий текст — і водночас те, чим пишуть документацію до функцій (побачимо в темі 14).

І четвертий, який рятує від війни зі слешами, — сирий рядок (raw string): літера r перед лапками вимикає обробку екранувань. r"C:\новий\текст" залишиться саме таким, як написано, а без r Python побачив би там \n і \t і мовчки зіпсував шлях. Регулярні вирази (тема 23) пишуть виключно так.

02 / ПослідовністьРядок — це послідовність символів

Рядок не є атомарною «одиницею тексту». Це впорядкована послідовність символів, у якої кожен має свій номер. Довжину дає вбудована функція len: len("Київ;кава;249.50") — це 16.

Нумерація починається з нуля. Перший символ — запис[0], останній — запис[15]. Здається сваволею, але за цим стоїть проста ідея: індекс — це не «котрий за рахунком», а відстань від початку. Нульовий символ стоїть на нульовій відстані від початку. З цієї ж думки далі природно виростуть зрізи.

Щоб не рахувати від кінця вручну, є від'ємні індекси: запис[-1] — останній символ, запис[-2] — передостанній. Правило перекладу просте: -k означає len(рядок) - k.

Вийти за межі не можна: запис[16] зупинить програму з IndexError: string index out of range. Це навмисно — краще гучна помилка одразу, ніж тихе сміття через сто рядків.

03 / ЗрізиЗрізи: взяти шматок

Найпотужніший інструмент цієї теми. Зріз (slice) бере не один символ, а цілий діапазон, і записується трьома числами через двокрапку:

Читається так: почни з start, зупинись перед stop, крокуй по step символів. Головна дивина тут — що stop не входить у результат. І це не примха, а рішення, яке дає дві дуже зручні властивості:

1. довжина зрізу = stop − start. запис[0:4] — це рівно чотири символи, рахувати нічого не треба;
2. шматки стикуються без дірок і без нахлесту. запис[:5] + запис[5:] дорівнює вихідному рядку — для будь-якого місця розрізу.

Будь-яке з трьох чисел можна пропустити, і тоді Python підставить розумне значення: start — початок, stop — кінець, step — одиницю. Тому запис[:4] — це «перші чотири», запис[-6:] — «останні шість», а запис[:] — увесь рядок цілком.

Окремо варто запам'ятати ідіому рядок[::-1]: від'ємний крок розвертає обхід, і ти отримуєш рядок навпаки. Покрути повзунки й подивись, як усе це виглядає на нашому записі.

04 / НезмінністьРядок не змінюється ніколи

А тепер головне речення теми. Спробуй виправити першу літеру:

Python відповість TypeError: 'str' object does not support item assignment. Не «помилка доступу», не «немає прав» — тип не підтримує таку операцію. Рядок незмінний (immutable), і жодного способу відредагувати його на місці не існує.

Звідси головний наслідок, який визначає весь стиль роботи з текстом: кожна «зміна» рядка — це насправді створення нового рядка. Методи .upper(), .replace(), .strip() нічого не правлять — вони повертають новий об'єкт, а старий лишається як був. Найчастіша помилка новачка виглядає рівно так:

Правильно — перевісити ярлик: напій = напій.upper(). Порівняй усі три випадки в інтерактиві, дивлячись на id об'єктів до і після.

Навіщо взагалі така незручність

Незмінність — не покарання, а плата за три конкретні речі, кожна з яких коштує дорого:

• Рядок можна класти в словник ключем. Хеш незмінного об'єкта рахується один раз і більше ніколи не змінюється. Якби рядок можна було редагувати, ключ у словнику «поїхав» би й значення загубилося. Про це — тема 08;
• Рядок безпечно передавати куди завгодно. Ти точно знаєш, що функція, якій ти дав ім'я користувача, не перепише його всередині;
• Однакові рядки можна не дублювати в пам'яті. Про це — в розділі 10.

05 / МетодиЧистимо, міняємо, шукаємо

Метод — це функція, «приклеєна» до об'єкта: пишеться через крапку після нього. Усі методи рядка повертають щось нове й ніколи не чіпають оригінал. Ось той мінімум, який покриває дев'яносто відсотків щоденної роботи.

Регістр

.upper() — усе великими, .lower() — усе малими, .title() — кожне слово з великої, .capitalize() — тільки перша літера всього рядка. Звучить нудно, поки не згадаєш, що регістр — це властивість мови, а не байтів: "ß".upper() дає "SS", тобто довжина рядка після зміни регістру може змінитись. А для порівняння без урахування регістру правильний метод — не .lower(), а .casefold(): він агресивніший і саме для цього призначений.

Прибирання країв

.strip() без аргументів знімає пробіли, табуляції й переходи рядка з обох кінців — перша дія над будь-яким рядком, прочитаним із файла чи від користувача. .lstrip() і .rstrip() роблять те саме з одного боку.

Заміна

.replace(старе, нове) замінює усі входження. Третім аргументом можна обмежити кількість: .replace(";", " · ", 1) замінить лише перше. Якщо старого підрядка немає, метод спокійно поверне копію без змін — помилки не буде.

Пошук

.find(що) повертає індекс першого входження або -1, якщо не знайшло. .rfind() шукає з кінця, .count() рахує входження, .startswith() і .endswith() перевіряють початок і кінець. А найпростіше питання «чи є там таке взагалі» ставлять оператором in: "кава" in запис.

06 / РозбірРозібрати й зібрати

Дві операції, які зустрічаються в реальному коді частіше за всі інші разом узяті.

.split(роздільник) ріже рядок на частини. .join(частини) склеює їх назад. Разом вони утворюють точну пару: розібрав, полагодив, зібрав.

Три тонкощі, на яких спотикаються всі.

1. .split() без аргументу — це інша операція. Вона ріже по будь-якій кількості будь-яких пробільних символів і викидає порожні шматки з країв. Тому "a b ".split() дає два елементи, а "a b ".split(" ") — аж чотири, два з яких порожні;
2. роздільник не «зникає» частково. Якщо він трапився двічі поспіль, між ними народиться порожній рядок. Це не баг: інакше не можна було б відрізнити «поле порожнє» від «поля немає»;
3. join — метод роздільника, а не списку. Пишеться навпаки до інтуїції: ";".join(частини). Логіка тут така: клеїти можна що завгодно, а от чим клеїти — це і є рядок, тому метод його.

07 / Форматf-рядки й міні-мова формату

Складати текст із плюсів — виснажливо й нечитабельно. Сучасний спосіб один: f-рядок (formatted string literal). Літера f перед лапками вмикає підстановку виразів у фігурних дужках:

Усередині дужок може стояти будь-який вираз, не лише ім'я: f"разом {ціна * 3} грн" працює. Два спеціальні прийоми варто знати одразу: f"{ціна!r}" друкує технічне представлення (repr) замість людського, а f"{ціна=}" друкує одразу й вираз, і значення — ціна=249.5. Другий — найшвидший спосіб налагодження, який взагалі існує в Python.

Двокрапка вмикає міні-мову

Після виразу можна поставити двокрапку й описати, як саме його надрукувати. Загальна форма специфікації така:

Найкорисніша комбінація — :>10.2f: фіксована ширина плюс фіксована точність. Саме вона перетворює купу чисел на охайну таблицю, де коми стоять одна під одною. Спробуй свою специфікацію:

08 / БайтиЛітери, коди й байти

Тепер обіцяний спойлер: у нашому записі шістнадцять символів, але двадцять чотири байти. Щоб зрозуміти чому, треба розділити три поняття, які в побуті злипаються в одне.

Найважливіше: len() рахує символи, а не байти. len("їжак") — це 4, хоча в UTF-8 воно займає 8 байтів. Так і має бути: коли ти питаєш довжину слова, тебе цікавлять літери.

str і bytes — це різні типи

.encode() перетворює рядок на байти, .decode() — назад:

Тип bytes пишеться з префіксом b і складається не з літер, а з чисел від 0 до 255. Складати його з рядком не можна: "Київ" + b"..." дасть TypeError: can only concatenate str (not "bytes") to str. Це навмисна стіна. У Python 2 такої стіни не було — і саме звідти походить ціле покоління програмістів з нервовим тиком на слові «кодування».

09 / ЦінаЧому += коштує дорого

Тепер повернімось до незмінності — і подивимось, у що вона обходиться, коли рядок треба складати шматками. Циклів ми ще не вчили (це тема 12), але ідея не потребує синтаксису: уяви, що ту саму дію повторюють багато разів поспіль.

Запис результат += шматок виглядає як «дописати». Насправді він означає результат = результат + шматок, а плюс над незмінними рядками — це створити третій рядок і скопіювати в нього обидва. На другому кроці копіюється вже вдвічі більше, на третьому — втричі. Кількість скопійованих символів росте квадратично від кількості кроків.

"".join(частини) робить те саме за один прохід: спершу рахує сумарну довжину, один раз виділяє пам'ять, один раз копіює кожен шматок. Лінійно замість квадратичного.

10 / НюансиДрібниці для тих, хто вже пише

Однакові рядки — не завжди один об'єкт

Пам'ятаєш is проти == з теми 03? Рядки — найкраще місце, щоб на цьому обпектися. Python економить пам'ять і інтернує (interning) частину рядків: тримає їх у спільній таблиці, щоб однаковий текст існував в одному екземплярі. Автоматично туди потрапляють ті, що схожі на ідентифікатори — самі лише латинські літери, цифри й підкреслення:

Третій випадок — залізний: рядок, склеєний під час роботи програми, завжди окремий об'єкт. Другий — ні: у файлі-модулі компілятор зазвичай зводить два однакові літерали в одну константу, а в Jupyter той самий код дає False. Саме тому висновок той самий, що й для чисел: рядки порівнюють через ==. is для них — джерело помилок, які проявляються раз на сто запусків. Якщо однаковість об'єктів справді потрібна (наприклад, мільйон повторюваних ключів у пам'яті), є явний інструмент sys.intern(), який кладе рядок у спільну таблицю сам.

Усередині Python зберігає не UTF-8

Здавалося б, після розділу 08 логічно припустити, що рядок у пам'яті лежить у UTF-8. Ні. CPython дивиться на найбільшу кодову позицію в рядку й обирає однакову ширину для всіх символів: 1 байт, якщо всі вміщаються, 2 байти, якщо є кирилиця, 4 — якщо є емодзі. Тому sys.getsizeof("abcd") дає 45 байтів, а sys.getsizeof("їжак") — уже 66.

Плата за пам'ять, зате виграш принциповий: індексація й довжина працюють за сталий час. Щоб дістати рядок[1000], достатньо арифметики, а не проходу з початку. У мовах, що тримають текст у UTF-8 напряму, «взяти тисячний символ» коштує тисячу кроків. Ось чому str і bytes у Python — принципово різні типи, а не два погляди на ті самі дані.

Порівняння рядків — за кодовими позиціями

"а" < "б" дає True, і здається, що сортування працює за абеткою. Не працює. Порівняння йде посимвольно за номерами Unicode, а вони збігаються з українською абеткою лише випадково. Літера ґ має номер 1169 — після всіх решти кириличних:

Для справжнього алфавітного порядку потрібне мовне правило сортування (collation) — або своя таблиця ваг символів, або зовнішня бібліотека. Просто пам'ятай: типове сортування рядків — це порядок кодів, а не абетка.

11 / ПідсумокЩо з цього забрати

• Рядок незмінний. s[0] = "X" не працює ніколи. Кожен метод повертає новий об'єкт — і якщо результат нікуди не записати, він зникне;
• Зріз — головний інструмент. s[start:stop:step], верхня межа не входить, будь-яке число можна пропустити, за межі не падає, s[::-1] розвертає;
• split і join — пара. Розібрав, полагодив, зібрав. join — метод роздільника й приймає тільки рядки;
• f-рядки — єдиний спосіб форматування, який варто вчити. Двокрапка вмикає міні-мову: ширина, вирівнювання, .2f, ,;
• Символи — не байти. len рахує символи, encode дає байти, кирилиця коштує 2 байти на літеру, і str з bytes не складаються;
• Збираєш багато — не +=, а join.

І наскрізна думка курсу, яка тут прозвучала вдруге: більшість «дивацтв» Python — це не дивацтва, а наслідки одного простого рішення. Незмінність рядка пояснює одразу все — і TypeError при спробі присвоєння, і те, що методи нічого не міняють, і квадратичність +=, і чому рядок можна класти ключем у словник. Одна властивість, шість наслідків.