> For the complete documentation index, see [llms.txt](https://olexsyn.gitbook.io/enote/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://olexsyn.gitbook.io/enote/progr/python/strings/built-in-methods.md).

# Built-in methods

### Вбудовані методи рядків у python <a href="#vstroennye-metody-strok-v-python" id="vstroennye-metody-strok-v-python"></a>

У посібнику за [типами змінних у python](https://pythonru.com/uroki/prisvoenie-tipa-peremennoj-uroki-po-python-dlja-nachinajushhih) ви дізналися, що Python — це об'єктно-орієнтована мова. Кожен елемент даних у програмі python є об'єктом.

Ви також знайомі з функціями: самостійними блоками коду, які можна викликати для виконання певних завдань.

<br>

Методи схожі функції. Метод - спеціалізований тип процедури, що викликається, тісно пов'язаний з об'єктом. Як і функція, метод викликається для виконання окремого завдання, але він викликається лише разом із певним об'єктом і знає про нього під час виконання.

Синтаксис для виклику методу об'єкта виглядає так:

```py
obj.foo(<args>)
```

Цей код викликає метод `.foo()`об'єкта `obj`. - аргументи, що передаються методом (якщо є).

Ви дізнаєтеся набагато більше про визначення та виклик методів пізніше у статтях про об'єктно-орієнтоване програмування. Зараз мета засвоїти вбудовані методи, що часто використовуються, які є в python для роботи з рядками.

У наведених методах аргументи, зазначені у квадратних дужках ( `[]`), є необов'язковими.

#### Зміна регістру рядка <a href="#izmenenie-registra-stroki" id="izmenenie-registra-stroki"></a>

Методи цієї групи виконують перетворення регістру рядка.

**`string.capitalize()`**&#x43D;аводить першу літеру у верхній регістр, інші у нижній.

`s.capitalize()`повертає копію `s`з першим символом, перетвореним на верхній регістр, та іншими символами, перетвореними на нижній регістр:

```py
>>> s = 'everyTHing yoU Can IMaGine is rEAl'
>>> s.capitalize()
'Everything you can imagine is real'
```

Не алфавітні символи не змінюються:

```py
>>> s = 'follow us @PYTHON'
>>> s.capitalize()
'Follow us @python'
```

**`string.lower()`**&#x43F;еретворює всі буквені символи на малі.

`s.lower()`повертає копію `s`з усіма літерними символами, перетвореними на нижній регістр:

```py
>>> 'everyTHing yoU Can IMaGine is rEAl'.lower()
'everything you can imagine is real'
```

**`string.swapcase()`**&#x437;мінює регістр буквених символів на протилежний.

`s.swapcase()`повертає копію `s`з великими літерними символами, перетвореними на малі і навпаки:

```py
>>> 'everyTHing yoU Can IMaGine is rEAl'.swapcase()
'EVERYthING YOu cAN imAgINE IS ReaL'
```

**`string.title()`**&#x43F;еретворює перші літери всіх слів у великі

`s.title()`повертає копію, `s`в якій перша літера кожного слова перетворюється на верхній регістр, а решта літер — у нижній регістр:

```py
>>> 'the sun also rises'.title()
'The Sun Also Rises'
```

Цей метод використовує досить простий алгоритм. Він не намагається розрізнити важливі та неважливі слова і не обробляє апострофи, імена чи абревіатури:

```py
>>> 'follow us @PYTHON'.title()
'Follow Us @Python'
```

**`string.upper()`**&#x43F;еретворює всі буквені символи на великі.

`s.upper()`повертає копію `s`з усіма літерними символами у верхньому регістрі:

```py
>>> 'follow us @PYTHON'.upper()
'FOLLOW US @PYTHON'
```

#### Знайти та замінити підрядок у рядку <a href="#naiti-i-zamenit-podstroku-v-stroke" id="naiti-i-zamenit-podstroku-v-stroke"></a>

Ці методи надають різні способи пошуку в цільовому рядку зазначеного підрядка.

Кожен метод у цій групі підтримує необов'язкові аргументи та аргументи. Вони визначають діапазон пошуку: дія методу обмежена частиною цільового рядка, що починається в позиції символу і триває аж до позиції символу , але не включаючи його. Якщо зазначено, а ні, метод застосовується до частини рядка від кінця.

**`string.count([, [, ]])`**&#x43F;ідраховує кількість входжень підрядка у рядок.

`s.count()`повертає кількість точних входжень підрядки в `s`:

```py
>>> 'foo goo moo'.count('oo')
3
```

Кількість входження зміниться, якщо вказати і :

```py
>>> 'foo goo moo'.count('oo', 0, 8)
2
```

**`string.endswith([, [, ]])`**&#x432;изначає, чи закінчується рядок заданим підрядком.

`s.endswith()`повертає, `True`якщо `s`закінчується зазначеним і `False`якщо ні:

```py
>>> 'python'.endswith('on')
True
>>> 'python'.endswith('or')
False
```

Порівняння обмежено підрядком, між і якщо вони вказані:

```py
>>> 'python'.endswith('yt', 0, 4)
True
>>> 'python'.endswith('yt', 2, 4)
False
```

**`string.find([, [, ]])`**&#x448;укає в рядку заданий підрядок.

`s.find()`повертає перший індекс у `s`який відповідає початку рядка :

```py
>>> 'Follow Us @Python'.find('Us')
7
```

Цей метод повертає, `-1`якщо зазначений підрядок не знайдено:

```py
>>> 'Follow Us @Python'.find('you')
-1
```

Пошук у рядку обмежується підрядком між і , якщо вони вказані:

```py
>>> 'Follow Us @Python'.find('Us', 4)
7
>>> 'Follow Us @Python'.find('Us', 4, 7)
-1
```

**`string.index([, [, ]])`**&#x448;укає в рядку заданий підрядок.

Цей метод ідентичний `.find()`, крім те що він викликає виняток `ValueError`, а то й знайдено:

```py
>>> 'Follow Us @Python'.index('you')
Traceback (most recent call last):
  File "", line 1, in <module>
    'Follow Us @Python'.index('you')
ValueError: substring not found
```

**`string.rfind([, [, ]])`**&#x448;укає в рядку заданий підрядок, починаючи з кінця.

`s.rfind()`повертає індекс останнього входження підрядка до `s`, який відповідає початку :

```py
>>> 'Follow Us @Python'.rfind('o')
15
```

Як і в `.find()`, якщо підрядок не знайдено, повертається `-1`:

```py
>>> 'Follow Us @Python'.rfind('a')
-1
```

Пошук у рядку обмежується підрядком між і , якщо вони вказані:

```py
>>> 'Follow Us @Python'.rfind('Us', 0, 14)
7
>>> 'Follow Us @Python'.rfind('Us', 9, 14)
-1
```

**`string.rindex([, [, ]])`**&#x448;укає в рядку заданий підрядок, починаючи з кінця.

Цей метод ідентичний `.rfind()`, крім те що він викликає виняток `ValueError`, а то й знайдено:

```py
>>> 'Follow Us @Python'.rindex('you')
Traceback (most recent call last):
  File "", line 1, in <module>
    'Follow Us @Python'.rindex('you')
ValueError: substring not found
```

**`string.startswith([, [, ]])`**&#x432;изначає, чи починається рядок із заданого підрядка.

`s.startswith()`повертає, `True`якщо `s`починається із зазначеного і `False`якщо ні:

```py
>>> 'Follow Us @Python'.startswith('Fol')
True
>>> 'Follow Us @Python'.startswith('Go')
False
```

Порівняння обмежено підрядком, між і якщо вони вказані:

```py
>>> 'Follow Us @Python'.startswith('Us', 7)
True
>>> 'Follow Us @Python'.startswith('Us', 8, 16)
False
```

#### Класифікація рядків <a href="#klassifikaciya-strok" id="klassifikaciya-strok"></a>

Методи у цій групі класифікують рядок на основі символів, які він містить.

**`string.isalnum()`**&#x432;изначає, чи складається рядок із літер та цифр.

`s.isalnum()`повертає `True`, якщо рядок `s`не порожній, а всі символи буквено-цифрові (або буква, або цифра). В іншому випадку `False`:

```py
>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False
```

**`string.isalpha()`**&#x432;изначає, чи складається рядок лише з літер.

`s.isalpha()`повертає `True`, якщо рядок `s`не порожній, а всі символи літерні. В іншому випадку `False`:

```py
>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False
```

**`string.isdigit()`**&#x432;изначає, чи складається рядок із цифр (перевірка на число).

`s.digit()`повертає `True`коли рядок `s`не порожній і всі його символи є цифрами, а якщо `False`ні:

```py
>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False
```

**`string.isidentifier()`**&#x432;изначає, чи є допустимим ідентифікатором Python.

`s.isidentifier()`повертає `True`, якщо `s`валідний ідентифікатор (назва змінної, функції, класу і т.д.) python, а якщо `False`ні:

```py
>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False
```

**Важливо:** `.isidentifier()` поверне `True`для рядка, який відповідає зарезервованому ключовому слову python, навіть якщо його не можна використовувати:

```py
>>> 'and'.isidentifier()
True
```

Ви можете перевірити, чи рядок є ключовим словом Python, використовуючи функцію `iskeyword()`, яка знаходиться в модулі `keyword`. Один із можливих способів зробити це:

```py
>>> from keyword import iskeyword
>>> iskeyword('and')
True
```

Якщо ви дійсно хочете переконатися, що рядок можна використовувати як python ідентифікатор, ви повинні перевірити, що `.isidentifier()`= `True`і `iskeyword()`= `False`.

**`string.islower()`**&#x432;изначає, чи є літерні символи рядка малими.

`s.islower()`повертає `True`, якщо рядок `s`не порожній, і всі літерні символи, що містяться в ньому, малі, а `False`якщо ні. Чи не алфавітні символи ігноруються:

```py
>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False
```

**`string.isprintable()`**&#x432;изначає, чи складається рядок лише з символів, що друкуються.

`s.isprintable()`повертає, `True`якщо рядок `s`порожній або всі літерні символи, які він містить, можна вивести на екран. Повертає, `False`якщо `s`містить хоч один спеціальний символ. Чи не алфавітні символи ігноруються:

```py
>>> 'a\tb'.isprintable() # \t - символ табуляции
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable() # \n - символ перевода строки
False
```

**Важливо:** Це єдиний `.is****()`метод, який повертає `True`, якщо `s`порожній рядок. Всі інші повертаються `False`.

**`string.isspace()`**&#x432;изначає, чи рядок складається лише з пробельних символів.

`s.isspace()`повертає `True`, якщо `s`не порожній рядок, і всі символи є пробельними, а `False`якщо ні.

Найбільш часто зустрічаються пробільні символи - це пробіл `' '`, табуляція `'\t'`і новий рядок `'\n'`:

```py
>>> ' \t  \n '.isspace()
True
>>> ' a '.isspace()
False
```

Тим не менш, є кілька символів ASCII, які вважаються пробілами. І якщо враховувати символи Юнікоду, їх ще більше:

```py
>>> '\f\u2005\r'.isspace()
True
```

`'\f'`та `'\r'`є escape-послідовностями для символів ASCII; `'\u2005'`це escape-послідовність для Unicode.

**`string.istitle()`**&#x432;изначає, чи починаються слова рядка з великої літери.

`s.istitle()`повертає `True`коли `s`не порожній рядок і перший алфавітний символ кожного слова у верхньому регістрі, а решта літерних символів у кожному слові малі. Повертає `False`, якщо ні:

```py
>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True
```

**`string.isupper()`**&#x432;изначає, чи є буквені символи рядка великими.

`s.isupper()`повертає `True`, якщо рядок `s`не порожня, і всі літерні символи, що містяться в ній, є великими, і в `False`, якщо ні. Чи не алфавітні символи ігноруються:

```py
>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False
```

#### Вирівнювання рядків, відступи <a href="#vyravnivanie-strok-otstupy" id="vyravnivanie-strok-otstupy"></a>

Методи цієї групи впливають виведення рядка.

**`string.center([, ])`**&#x432;ирівнює рядок по центру.

`s.center()`повертає рядок, що складається з `s`вирівняної по ширині . За замовчуванням відступ складається з пробілу ASCII:

```py
>>> 'py'.center(10)
'    py    '
```

Якщо вказано необов'язковий аргумент , він використовується як символ заповнення:

```py
>>> 'py'.center(10, '-')
'----py----'
```

Якщо `s`більше або дорівнює , рядок повертається без змін:

```py
>>> 'python'.center(2)
'python'
```

**`string.expandtabs(tabsize=8)`**&#x437;амінює табуляції на прогалини

`s.expandtabs()`замінює кожен символ табуляції ( `'\t'`) пробілами. За замовчуванням табуляція замінюється на 8 пробілів:

```py
>>> 'a\tb\tc'.expandtabs()
'a       b       c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa     bbb     c'
```

`tabsize`необов'язковий параметр, що задає кількість прогалин:

```py
>>> 'a\tb\tc'.expandtabs(4)
'a   b   c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'
```

**`string.ljust([, ])`**&#x432;ирівнювання лівим краєм рядка в полі.

`s.ljust()`повертає рядок `s`, вирівняний по лівому краю в полі завширшки . За замовчуванням відступ складається з пробілу ASCII:

```py
>>> 'python'.ljust(10)
'python    '
```

Якщо вказано аргумент , він використовується як символ заповнення:

```py
>>> 'python'.ljust(10, '-')
'python----'
```

Якщо `s`більше або дорівнює , рядок повертається без змін:

```py
>>> 'python'.ljust(2)
'python'
```

**`string.lstrip([])`**&#x43E;брізає пробільні символи зліва

`s.lstrip()`повертає копію `s`, в якій всі пробілові символи з лівого краю видалені:

```py
>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'
```

Необов'язковий аргумент визначає набір символів, які будуть видалені:

```py
>>> 'https://www.pythonru.com'.lstrip('/:pths')
'www.pythonru.com'
```

**`string.replace(, [, ])`**&#x437;амінює входження підрядки у рядку.

`s.replace(, )`повертає копію `s`де всі входження підрядки , замінені на :

```py
>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love')
'I love python! I love python! I love python!'
```

Якщо вказано необов'язковий аргумент , виконується кількість замін:

```py
>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love', 2)
'I love python! I love python! I hate python!'
```

**`string.rjust([, ])`**&#x432;ирівнювання з правого краю рядка в полі.

`s.rjust()`повертає рядок `s`, вирівняний праворуч у полі шириною . За замовчуванням відступ складається з пробілу ASCII:

```py
>>> 'python'.rjust(10)
'    python'
```

Якщо вказано аргумент , він використовується як символ заповнення:

```py
>>> 'python'.rjust(10, '-')
'----python'
```

Якщо `s`більше або дорівнює , рядок повертається без змін:

```py
>>> 'python'.rjust(2)
'python'
```

**`string.rstrip([])`**&#x43E;брізає пробільні символи праворуч

`s.rstrip()`повертає копію `s`без пробілів, видалених з правого краю:

```py
>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'
```

Необов'язковий аргумент визначає набір символів, які будуть видалені:

```py
>>> 'foo.$$$;'.rstrip(';$.')
'foo'
```

**`string.strip([])`**&#x432;идаляє символи з лівого та правого краю рядка.

`s.strip()`еквівалентно послідовному виклику `s.lstrip()`та `s.rstrip()`. Без аргументу метод видаляє прогалини на початку та наприкінці:

```py
>>> s = '   foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'
```

Як `.lstrip()`і `.rstrip()`, необов'язковий аргумент визначає набір символів, які будуть видалені:

```py
>>> 'www.pythonru.com'.strip('w.moc')
'pythonru'
```

**Важливо:** Коли значення методу, що повертається, є іншим рядком, як це часто буває, методи можна викликати послідовно:

```py
>>> '   foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar baz\t\t\t'.strip()
'foo bar baz'

>>> 'www.pythonru.com'.lstrip('w.').rstrip('.moc')
'pythonru'
>>> 'www.pythonru.com'.strip('w.moc')
'pythonru'
```

**`string.zfill()`**&#x434;оповнює рядок нулями зліва.

`s.zfill()`повертає копію `s`доповнену `'0'`ліворуч для досягнення довжини рядка вказаної в :

```py
>>> '42'.zfill(5)
'00042'
```

Якщо `s`містить знак перед цифрами, він залишається зліва рядка:

```py
>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'
```

Якщо `s`більше або дорівнює , рядок повертається без змін:

```py
>>> '-42'.zfill(3)
'-42'
```

`.zfill()`найбільш корисний для рядкових уявлень чисел, але python із задоволенням заповнить рядок нулями, навіть якщо в ньому немає чисел:

```py
>>> 'foo'.zfill(6)
'000foo'
```

#### Методи перетворення рядка до списку <a href="#metody-preobrazovanie-stroki-v-spisok" id="metody-preobrazovanie-stroki-v-spisok"></a>

Методи у цій групі перетворюють рядок на інший тип даних і навпаки. Ці методи повертають або приймають об'єкти, що ітеруються, — термін Python для послідовного набору об'єктів.

Багато з цих методів повертають або список, або кортеж. Це два схожі типи даних, які є прототипами прикладів ітерацій у python. Список укладений у квадратні дужки ( `[]`), а кортеж укладено у прості ( `()`).

Тепер погляньмо на останню групу рядкових методів.

**`string.join()`**&#x43F;оєднує список у рядок.

`s.join()`повертає рядок, який є результатом конкатенації об'єкта з роздільником `s`.

Зверніть увагу, що `.join()`викликається рядок-розділювач `s`. має бути послідовністю рядкових об'єктів.

Приклади коду допоможуть уникнути. У першому прикладі роздільником `s`є ​​рядок `', '`, а список рядків:

```py
>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'
```

В результаті виходить один рядок, що складається зі списку об'єктів, розділених комами.

У наступному прикладі вказується як одне рядкове значення. Коли рядкове значення використовується як ітерований, воно інтерпретується як список окремих символів рядка:

```py
>>> list('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'.join('corge')
'c:o:r:g:e'
```

Таким чином, результатом `':'.join('corge')`є рядок, що складається з кожного символу `'corge'`, розділеного символом `':'`.

Цей приклад завершується з помилкою `TypeError`, тому що один з об'єктів не є рядком:

```py
>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "", line 1, in <module>
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found
```

Це можна виправити так:

```py
>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'
```

Як ви скоро побачите, багато об'єктів в Python можна ітерувати, і `.join()`особливо корисний для створення рядків.

**`string.partition()`**&#x434;ілить рядок на основі роздільника.

`s.partition()`відокремлює від `s`підрядок довжиною від початку до першого входження . Значення, що повертається, являє собою кортеж з трьох частин:

* Частина `s`до
* Розділювач
* Частина `s`після

Ось пара прикладів `.partition()`у роботі:

```py
>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')
```

Якщо не знайдено в `s`, повертається кортеж містить `s`два порожні рядки:

```py
>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')
```

`s.rpartition()`ділить рядок на основі роздільника, починаючи з кінця.

`s.rpartition()`працює як , за винятком того, що ділиться при останньому входженні замість першого:`s.partition()s`

```py
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')
```

**`string.rsplit(sep=None, maxsplit=-1)`**&#x434;ілить рядок на список із підрядків.

Без аргументів `s.rsplit()`ділить `s`на підрядки, розділені будь-якою послідовністю прогалин, і повертає список:

```py
>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar   baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']
```

Якщо зазначено, він використовується як роздільник:

```py
>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']
```

Якщо = `None`, рядок розділяється пробілами, якби не було вказано взагалі.

Коли явно вказано як роздільник `s`, послідовні повтори роздільника будуть повернуті як порожні рядки:

```py
>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']
```

Це не працює, коли не вказано. У цьому випадку послідовні символи пробілів об'єднуються в один роздільник, і результуючий список ніколи не міститиме порожніх рядків:

```py
>>> 'foo\t\t\tbar'.rsplit()
['foo', 'bar']
```

Якщо вказано необов'язковий параметр , виконується максимальна кількість поділів, починаючи з правого краю `s`:

```py
>>> 'www.pythonru.com'.rsplit(sep='.', maxsplit=1)
['www.pythonru', 'com']
```

Стандартне значення для — `-1`. Це означає, що всі можливі поділи мають бути виконані:

```py
>>> 'www.pythonru.com'.rsplit(sep='.', maxsplit=-1)
['www', 'pythonru', 'com']
>>> 'www.pythonru.com'.rsplit(sep='.')
['www', 'pythonru', 'com']
```

**`string.split(sep=None, maxsplit=-1)`**&#x434;ілить рядок на список із підрядків.

`s.split()`веде себе як `s.rsplit()`, за винятком того, що при вказівці , розподіл починається з лівого краю `s`:

```py
>>> 'www.pythonru.com'.split('.', maxsplit=1)
['www', 'pythonru.com']
>>> 'www.pythonru.com'.rsplit('.', maxsplit=1)
['www.pythonru', 'com']
```

Якщо не вказано, між `.rsplit()`і `.split()`в python різниці немає.

**`string.splitlines([])`**&#x434;ілить текст на список рядків.

`s.splitlines()`ділить `s`на рядки та повертає їх у списку. Будь-який із наступних символів або послідовностей символів вважається межею рядка:

| Розділювач  | Значення                            |
| ----------- | ----------------------------------- |
|             | Новий рядок                         |
|             | Повернення каретки                  |
| \r          | Повернення каретки + переклад рядка |
| \v або \x0b | Таблиці рядків                      |
| \f або \x0c | Подання форми                       |
| \x1c        | Розділювач файлів                   |
| \x1d        | Розділювач груп                     |
| \x1e        | Розділювач записів                  |
| 85          | Наступний рядок                     |
| &2028       | Новий рядок (Unicode)               |
| &2029       | Новий абзац (Unicode)               |

Ось приклад використання декількох різних роздільників рядків:

```py
>>> 'foo\nbar\r\nbaz\fqux\u2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']
```

Якщо у рядку присутні послідовні символи межі рядка, вони з'являться у списку результатів як порожні рядки:

```py
>>> 'foo\f\f\fbar'.splitlines()
['foo', '', '', 'bar']
```

Якщо необов'язковий аргумент вказано і його булеве значення `True`, то символи межі рядків зберігаються у списку підрядків:

```py
>>> 'foo\nbar\nbaz\nqux'.splitlines(True)
['foo\n', 'bar\n', 'baz\n', 'qux']
>>\> 'foo\nbar\nbaz\nqux'.splitlines(8)
['foo\n', 'bar\n', 'baz\n', 'qux']
```

<br>