# 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>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://olexsyn.gitbook.io/enote/progr/python/strings/built-in-methods.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.