Питон работа со строками: Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы

Содержание

Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы

Петр Смолович

ведущий разработчик хостинг-провайдера и регистратора доменов REG.RU

В этой статье мы разберем работу со строками в Python с необычного угла — глазами интервьюера на собеседовании. Информация будет полезна как новичку, так и уверенному джуну. В первой части поговорим о базовых операциях. Во второй — разберем примеры задач и вопросов, к которым стоит быть готовым.

Итак, мы на собеседовании, и я хочу узнать, умеете ли вы обращаться со строками.

Как склеить две строки?

>>> s = "abc" + "def"
>>> s += "xyz"

Элементарно? Почти. Важно помнить, что строки — это неизменяемые объекты. Каждый раз, когда мы говорим про «изменение» строки, технически мы создаем новый объект и записываем туда вычисленное значение.

А как склеить три строки? Напрашивается ответ «точно так же», и иногда это самый лучший способ. Но интервьюер скорее всего хочет проверить, знаете ли вы про метод . join()

>>> names = ["John", "Paul", "Ringo", "George"]
>>> ", ".join(names)
'John, Paul, Ringo, George'

join() — очень удобный метод, позволяющий склеить N строк, причём с произвольным разделителем.

Здесь важно не только получить результат, но и понимать, как работает приведённая конструкция. А именно, что join() — это метод объекта «строка», принимающий в качестве аргумента список и возвращающий на выходе новую строку.
Кстати, хорошая задачка для интервью — написать свою реализацию join().

Разделить строки?

Есть несколько способов получить часть строки. Первый — это split, обратный метод для join. В отличие от join

’а, он применяется к целевой строке, а разделитель передаётся аргументом.

>>> s = "Альфа, Браво, Чарли"
>>> s.split(", ")
['Альфа', 'Браво', 'Чарли']

Второй — срезы (slices).

Срез s[x:y] позволяет получить подстроку с символа x до символа y. Можно не указывать любое из значений, чтобы двигаться с начала или до конца строки. Отрицательные значения используются для отсчёта с конца (-1 — последний символ, -2 — предпоследний и т.п.).

>>> s = "Hello, world!"
>>> print(s[0:5])
Hello
>>> print(s[-6:])
world!

При помощи необязательного третьего параметра s[x:y:N] можно выбрать из подстроки каждый N-ый символ. Например, получить только чётные или только нечётные символы:

>>> s = "0123456789"
>>> print(s[::2])
02468
>>> print(s[1::2])
13579

Что насчёт поиска в строке?

Самое быстрое — проверить, начинается ли (заканчивается ли) строка с выбранных символов. Для этого в Python предусмотрены специальные строковые методы.

>>> s = "0123456789"
>>> s.startswith("012")
True
>>> s.endswith("69")
False

Для поиск подстроки в произвольном месте есть метод с говорящим названием find().

/]+)(.*)$», s) >>> print(result.group(1)) https >>> print(result.group(2)) www.reg.ru >>> print(result.group(3)) /hosting/

А замену в строке сделать сможете?

Во-первых, при помощи срезов и склейки строк можно заменить что угодно.

>>> s = "Hello, darling! How are you?"
>>> s[:7] + "Василий" + s[14:]
'Hello, Василий! How are you?'

Во-вторых, умеешь find(), умей и replace().

>>> s.replace("darling", "Василий")
'Hello, Василий! How are you?'

В-третьих, любую проблему можно решить регулярными выражениями. Либо получить две проблемы 🙂 В случае с заменой вам нужен метод

re.sub().

>>> s = "https://www.reg.ru/hosting/";
>>> import re
>>> print(re.sub('[a-z]', 'X', s))
XXXXX://XXX.XXX.XX/XXXXXXX/

Посимвольная обработка?

Есть бесчисленное множество задачек, которые можно решить, пройдясь в цикле по строке. Например, посчитать количество букв «о».

>>> s = "Hello, world!"
>>> for c in s:
>>>     if c == "o":
>>>         counter += 1
>>> print(counter)
2

Иногда удобнее бежать по индексу.

>>> for i in range(len(s)):
>>>     if s[i] == "o":
>>>         counter += 1

Помним, что строки неизменяемы, поэтому подменить i-ый символ по индексу не получится, нужно создавать новый объект:

>>> s[i] = "X"
Traceback (most recent call last):
File "", line 1, in 
TypeError: 'str' object does not support item assignment
>>> s[:i] + "X" + s[i+1:]
'HellX, world!'

Либо можно преобразовать строку в список, сделать обработку, а потом склеить список обратно в строку:

>>> arr = list(s)
>>> "".join(arr)
'Hello, world!'

А форматирование строк?

Типичная жизненная необходимость — сформировать строку, подставив в неё результат работы программы.

Начиная с Python 3.6, это можно делать при помощи f-строк:

>>> f"Строка '{s}' содержит {len(s)} символов."
"Строка 'Hello, world!' содержит 13 символов."

В более старом коде можно встретить альтернативные способы

>>> "Строка '%s' содержит %d символов" % (s, len(s))
>>> "Строка '{}' содержит {} символов".format(s, len(s))

Технически можно было обойтись склейкой, но это менее элегантно, а еще придётся следить, чтобы все склеиваемые кусочки были строками. Не рекомендую:

>>> "Строка '" + s + "' содержит " + str(len(s)) + " символов."
"Строка 'Hello, world!' содержит 13 символов."

***

Цель работодателя на собеседовании — убедиться что вы соображаете и что вы справитесь с реальными задачами. Однако погружение в реальные задачи занимает несколько недель, а время интервью ограничено. Поэтому вас ждут учебные задания, которые можно решить за 10-30 минут, а также вопросы на понимание того, как работает код. О них и поговорим в следующей части.

работа со строками, форматирование,методы split, strip

В уроке по присвоению типа переменной в Python вы могли узнать, как определять строки: объекты, состоящие из последовательности символьных данных. Обработка строк неотъемлемая частью программирования на python. Крайне редко приложение, не использует строковые типы данных.

Из этого урока вы узнаете: Python предоставляет большую коллекцию операторов, функций и методов для работы со строками. Когда вы закончите изучение этой документации, узнаете, как получить доступ и извлечь часть строки, а также познакомитесь с методами, которые доступны для манипулирования и изменения строковых данных.

Ниже рассмотрим операторы, методы и функции, доступные для работы с текстом.

Строковые операторы

Вы уже видели операторы + и * в применении их к числовым значениям в уроке по операторам в Python . Эти два оператора применяются и к строкам.

Оператор сложения строк

+

+ — оператор конкатенации строк. Он возвращает строку, состоящую из других строк, как показано здесь:

>>> s = 'py'
>>> t = 'th'
>>> u = 'on'
>>> s + t
'pyth'
>>> s + t + u
'python'
>>> print('Привет, ' + 'Мир!')
Go team!!!

Оператор умножения строк

*

* — оператор создает несколько копий строки. Если s это строка, а n целое число, любое из следующих выражений возвращает строку, состоящую из n объединенных копий s:

s * n
n * s

Вот примеры умножения строк:

>>> s = 'py.'
>>> s * 4
'py.py.py.py.'
>>> 4 * s
'py.py.py.py.'

Значение множителя n должно быть целым положительным числом. Оно может быть нулем или отрицательным, но этом случае результатом будет пустая строка:

>>> 'py' * -6
''

Если вы создадите строковую переменную и превратите ее в пустую строку, с помощью 'py' * -6, кто-нибудь будет справедливо считать вас немного глупым. Но это сработает.

Оператор принадлежности подстроки

in

Python также предоставляет оператор принадлежности, который можно использоваться для манипуляций со строками. Оператор in возвращает

True, если подстрока входит в строку, и False, если нет:

>>> s = 'Python'
>>> s in 'I love Python.'
True
>>> s in 'I love Java.'
False

Есть также оператор not in, у которого обратная логика:

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

Встроенные функции строк в python

Python предоставляет множество функций, которые встроены в интерпретатор. Вот несколько, которые работают со строками:

Функция	Описание
chr()	Преобразует целое число в символ
ord()	Преобразует символ в целое число
len()	Возвращает длину строки
str()	Изменяет тип объекта на `string`

Более подробно о них ниже.

Функция ord(c) возвращает числовое значение для заданного символа.

На базовом уровне компьютеры хранят всю информацию в виде цифр. Для представления символьных данных используется схема перевода, которая содержит каждый символ с его репрезентативным номером.

Самая простая схема в повседневном использовании называется ASCII . Она охватывает латинские символы, с которыми мы чаще работает. Для этих символов ord(c)

возвращает значение ASCII для символа c:

>>> ord('a')
97
>>> ord('#')
35

ASCII прекрасен, но есть много других языков в мире, которые часто встречаются. Полный набор символов, которые потенциально могут быть представлены в коде, намного больше обычных латинских букв, цифр и символом.

Unicode — это современный стандарт, который пытается предоставить числовой код для всех возможных символов, на всех возможных языках, на каждой возможной платформе. Python 3 поддерживает Unicode, в том числе позволяет использовать символы Unicode в строках.

Функция ord() также возвращает числовые значения для символов Юникода:

>>> ord('€')
8364
>>> ord('∑')
8721

Функция chr(n) возвращает символьное значение для данного целого числа.

chr() действует обратно ord(). Если задано числовое значение n, chr(n) возвращает строку, представляющую символ n:

>>> chr(97)
'a'
>>> chr(35)
'#'

chr() также обрабатывает символы Юникода:

>>> chr(8364)
'€'
>>> chr(8721)
'∑'

Функция len(s) возвращает длину строки.

len(s) возвращает количество символов в строке s:

>>> s = 'Простоя строка.'
>>> len(s)
15

Функция str(obj) возвращает строковое представление объекта.

Практически любой объект в Python может быть представлен как строка. str(obj) возвращает строковое представление объекта obj:

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('py')
'py'

Индексация строк

Часто в языках программирования, отдельные элементы в упорядоченном наборе данных могут быть доступны с помощью числового индекса или ключа. Этот процесс называется индексация.

В Python строки являются упорядоченными последовательностями символьных данных и могут быть проиндексированы. Доступ к отдельным символам в строке можно получить, указав имя строки, за которым следует число в квадратных скобках [].

Индексация строк начинается с нуля: у первого символа индекс 0, следующего 1 и так далее. Индекс последнего символа в python — ‘‘длина строки минус один’’.

Например, схематическое представление индексов строки 'foobar' выглядит следующим образом:

Отдельные символы доступны по индексу следующим образом:

>>> s = 'foobar'
>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> s[5]
'r'

Попытка обращения по индексу большему чем len(s) - 1, приводит к ошибке IndexError:

>>> s[6]
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    s[6]
IndexError: string index out of range

Индексы строк также могут быть указаны отрицательными числами. В этом случае индексирование начинается с конца строки: -1 относится к последнему символу, -2 к предпоследнему и так далее. Вот такая же диаграмма, показывающая как положительные, так и отрицательные индексы строки 'foobar':

Вот несколько примеров отрицательного индексирования:

>>> s = 'foobar'
>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)] # отрицательная индексация начинается с -1
'f'

Попытка обращения по индексу меньшему чем -len(s), приводит к ошибке IndexError:

>>> s[-7]
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    s[-7]
IndexError: string index out of range

Для любой непустой строки s, код s[len(s)-1] и s[-1] возвращают последний символ. Нет индекса, который применим к пустой строке.

Срезы строк

Python также допускает возможность извлечения подстроки из строки, известную как ‘‘string slice’’. Если s это строка, выражение формы s[m:n] возвращает часть s, начинающуюся с позиции m, и до позиции n, но не включая позицию:

>>> s = 'python'
>>> s[2:5]
'tho'

Помните: индексы строк в python начинаются с нуля. Первый символ в строке имеет индекс 0. Это относится и к срезу.

Опять же, второй индекс указывает символ, который не включен в результат. Символ 'n' в приведенном выше примере. Это может показаться немного не интуитивным, но дает результат: выражение s[m:n] вернет подстроку, которая является разницей n - m, в данном случае 5 - 2 = 3.

Если пропустить первый индекс, срез начинается с начала строки. Таким образом, s[:m] = s[0:m]:

>>> s = 'python'
>>> s[:4]
'pyth'
>>> s[0:4]
'pyth'

Аналогично, если опустить второй индекс s[n:], срез длится от первого индекса до конца строки. Это хорошая, лаконичная альтернатива более громоздкой s[n:len(s)]:

>>> s = 'python'
>>> s[2:]
'thon'
>>> s[2:len(s)]
'thon'

Для любой строки s и любого целого n числа (0 ≤ n ≤ len(s)), s[:n] + s[n:]будет s:

>>> s = 'python'
>>> s[:4] + s[4:]
'python'
>>> s[:4] + s[4:] == s
True

Пропуск обоих индексов возвращает исходную строку. Это не копия, это ссылка на исходную строку:

>>> s = 'python'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

Если первый индекс в срезе больше или равен второму индексу, Python возвращает пустую строку. Это еще один не очевидный способ сгенерировать пустую строку, если вы его искали:

>>> s[2:2]
''
>>> s[4:2]
''

Отрицательные индексы можно использовать и со срезами. Вот пример кода Python:

>>> s = 'python'
>>> s[-5:-2]
'yth'
>>> s[1:4]
'yth'
>>> s[-5:-2] == s[1:4]
True

Шаг для среза строки

Существует еще один вариант синтаксиса среза, о котором стоит упомянуть. Добавление дополнительного : и третьего индекса означает шаг, который указывает, сколько символов следует пропустить после извлечения каждого символа в срезе.

Например , для строки 'python' срез 0:6:2 начинается с первого символа и заканчивается последним символом (всей строкой), каждый второй символ пропускается. Это показано на следующей схеме:

Иллюстративный код показан здесь:

>>> s = 'foobar'
>>> s[0:6:2]
'foa'
>>> s[1:6:2]
'obr'

Как и в случае с простым срезом, первый и второй индексы могут быть пропущены:

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'

Вы также можете указать отрицательное значение шага, в этом случае Python идет с конца строки. Начальный/первый индекс должен быть больше конечного/второго индекса:

>>> s = 'python'
>>> s[5:0:-2]
'nhy'

В приведенном выше примере, 5:0:-2 означает «начать с последнего символа и делать два шага назад, но не включая первый символ. ”

Когда вы идете назад, если первый и второй индексы пропущены, значения по умолчанию применяются так: первый индекс — конец строки, а второй индекс — начало. Вот пример:

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'

Это общая парадигма для разворота (reverse) строки:

>>> s = 'Если так говорит товарищ Наполеон, значит, так оно и есть.'
>>> s[::-1]
'.ьтсе и оно кат ,тичанз ,ноелопаН щиравот тировог кат илсЕ'

Форматирование строки

В Python версии 3.6 был представлен новый способ форматирования строк. Эта функция официально названа литералом отформатированной строки, но обычно упоминается как f-string.

Возможности форматирования строк огромны и не будут подробно описана здесь.
Одной простой особенностью f-строк, которые вы можете начать использовать сразу, является интерполяция переменной. Вы можете указать имя переменной непосредственно в f-строковом литерале (f'string'), и python заменит имя соответствующим значением.

Например, предположим, что вы хотите отобразить результат арифметического вычисления. Это можно сделать с помощью простого print() и оператора ,, разделяющего числовые значения и строковые:

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('Произведение', n, 'на', m, 'равно', prod)
Произведение 20 на 25 равно 500

Но это громоздко. Чтобы выполнить то же самое с помощью f-строки:

Напишите f или F перед кавычками строки. Это укажет python, что это f-строка вместо стандартной.
Укажите любые переменные для воспроизведения в фигурных скобках ({}).

Код с использованием f-string, приведенный ниже выглядит намного чище:

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'Произведение {n} на {m} равно {prod}')
Произведение 20 на 25 равно 500

Любой из трех типов кавычек в python можно использовать для f-строки:

>>> var = 'Гав'
>>> print(f'Собака говорит {var}!')
Собака говорит Гав!
>>> print(f"Собака говорит {var}!")
Собака говорит Гав!
>>> print(f'''Собака говорит {var}!''')
Собака говорит Гав!

Изменение строк

Строки — один из типов данных, которые Python считает неизменяемыми, что означает невозможность их изменять. Как вы ниже увидите, python дает возможность ~~изменять~~ (заменять и перезаписывать) строки.

Такой синтаксис приведет к ошибке TypeError:

>>> s = 'python'
>>> s[3] = 't'
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    s[3] = 't'
TypeError: 'str' object does not support item assignment

На самом деле нет особой необходимости изменять строки. Обычно вы можете легко сгенерировать копию исходной строки с необходимыми изменениями. Есть минимум 2 способа сделать это в python. Вот первый:

>>> s = s[:3] + 't' + s[4:]
>>> s
'pytton'

Есть встроенный метод string.replace(x, y):

>>> s = 'python'
>>> s = s.replace('h', 't')
>>> s
'pytton'

Читайте дальше о встроенных методах строк!

Встроенные методы строк в python

В руководстве по типам переменных в python вы узнали, что Python — это объектно-ориентированный язык. Каждый элемент данных в программе python является объектом.

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

Методы похожи на функции. Метод — специализированный тип вызываемой процедуры, тесно связанный с объектом. Как и функция, метод вызывается для выполнения отдельной задачи, но он вызывается только вместе с определенным объектом и знает о нем во время выполнения.

Синтаксис для вызова метода объекта выглядит следующим образом:

obj.foo(<args>)

Этот код вызывает метод .foo() объекта obj. <args> — аргументы, передаваемые методу (если есть).

Вы узнаете намного больше об определении и вызове методов позже в статьях про объектно-ориентированное программирование. Сейчас цель усвоить часто используемые встроенные методы, которые есть в python для работы со строками.

В приведенных методах аргументы, указанные в квадратных скобках ([]), являются необязательными.

Изменение регистра строки

Методы этой группы выполняют преобразование регистра строки.

string.capitalize() приводит первую букву в верхний регистр, остальные в нижний.

s.capitalize() возвращает копию s с первым символом, преобразованным в верхний регистр, и остальными символами, преобразованными в нижний регистр:

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

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

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

string.lower() преобразует все буквенные символы в строчные.

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

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

string. swapcase() меняет регистр буквенных символов на противоположный.

s.swapcase() возвращает копию s с заглавными буквенными символами, преобразованными в строчные и наоборот:

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

string.title() преобразует первые буквы всех слов в заглавные

s.title() возвращает копию, s в которой первая буква каждого слова преобразуется в верхний регистр, а остальные буквы — в нижний регистр:

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

Этот метод использует довольно простой алгоритм. Он не пытается различить важные и неважные слова и не обрабатывает апострофы, имена или аббревиатуры:

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

string.upper() преобразует все буквенные символы в заглавные.

s. upper() возвращает копию s со всеми буквенными символами в верхнем регистре:

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

Найти и заменить подстроку в строке

Эти методы предоставляют различные способы поиска в целевой строке указанной подстроки.

Каждый метод в этой группе поддерживает необязательные аргументы <start> и <end> аргументы. Они задают диапазон поиска: действие метода ограничено частью целевой строки, начинающейся в позиции символа <start> и продолжающейся вплоть до позиции символа <end>, но не включая его. Если <start> указано, а <end> нет, метод применяется к части строки от <start> конца.

string.count([, <start>[, <end>]]) подсчитывает количество вхождений подстроки в строку.

s.count() возвращает количество точных вхождений подстроки  в s:

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

Количество вхождений изменится, если указать <start> и <end>:

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

string.endswith(<suffix>[, <start>[, <end>]]) определяет, заканчивается ли строка заданной подстрокой.

s.endswith(<suffix>) возвращает, True если s заканчивается указанным <suffix> и False если нет:

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

Сравнение ограничено подстрокой, между <start> и <end>, если они указаны:

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

string.find([, <start>[, <end>]]) ищет в строке заданную подстроку.

s.find() возвращает первый индекс в s который соответствует началу строки :

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

Этот метод возвращает, -1 если указанная подстрока не найдена:

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

Поиск в строке ограничивается подстрокой, между <start> и <end>, если они указаны:

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

string.index([, <start>[, <end>]]) ищет в строке заданную подстроку.

Этот метод идентичен .find(), за исключением того, что он вызывает исключение ValueError, если  не найден:

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

string.rfind([, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.

s.rfind() возвращает индекс последнего вхождения подстроки  в s, который соответствует началу :

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

Как и в .find(), если подстрока не найдена, возвращается -1:

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

Поиск в строке ограничивается подстрокой, между <start> и <end>, если они указаны:

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

string.rindex([, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.

Этот метод идентичен .rfind(), за исключением того, что он вызывает исключение ValueError, если  не найден:

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

string.startswith(<prefix>[, <start>[, <end>]]) определяет, начинается ли строка с заданной подстроки.

s.startswith(<suffix>) возвращает, True если s начинается с указанного <suffix> и False если нет:

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

Сравнение ограничено подстрокой, между <start> и <end>, если они указаны:

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

Классификация строк

Методы в этой группе классифицируют строку на основе символов, которые она содержит.

string.isalnum() определяет, состоит ли строка из букв и цифр.

s.isalnum() возвращает True, если строка s не пустая, а все ее символы буквенно-цифровые (либо буква, либо цифра). В другом случае False :

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

string.isalpha() определяет, состоит ли строка только из букв.

s.isalpha() возвращает True, если строка s не пустая, а все ее символы буквенные. В другом случае False:

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

string.isdigit() определяет, состоит ли строка из цифр (проверка на число).

s.digit() возвращает True когда строка s не пустая и все ее символы являются цифрами, а в False если нет:

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

string.isidentifier() определяет, является ли строка допустимым идентификатором Python.

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

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

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

>>> 'and'.isidentifier()
True

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

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

Если вы действительно хотите убедиться, что строку можно использовать как идентификатор python, вы должны проверить, что .isidentifier() = True и iskeyword() = False.

string.islower() определяет, являются ли буквенные символы строки строчными.

s.islower() возвращает True, если строка s не пустая, и все содержащиеся в нем буквенные символы строчные, а False если нет. Не алфавитные символы игнорируются:

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

string.isprintable() определяет, состоит ли строка только из печатаемых символов.

s.isprintable() возвращает, True если строка s пустая или все буквенные символы которые она содержит можно вывести на экран. Возвращает, False если s содержит хотя бы один специальный символ. Не алфавитные символы игнорируются:

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

Важно: Это единственный .is****() метод, который возвращает True, если s пустая строка. Все остальные возвращаются False.

string.isspace() определяет, состоит ли строка только из пробельных символов.

s.isspace() возвращает True, если s не пустая строка, и все символы являются пробельными, а False, если нет.

Наиболее часто встречающиеся пробельные символы — это пробел ' ', табуляция '\t' и новая строка '\n':

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

Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:

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

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

string.istitle() определяет, начинаются ли слова строки с заглавной буквы.

s.istitle() возвращает True когда s не пустая строка и первый алфавитный символ каждого слова в верхнем регистре, а все остальные буквенные символы в каждом слове строчные. Возвращает False, если нет:

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

string.isupper() определяет, являются ли буквенные символы строки заглавными.

s.isupper() возвращает True, если строка s не пустая, и все содержащиеся в ней буквенные символы являются заглавными, и в False, если нет. Не алфавитные символы игнорируются:

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

Выравнивание строк, отступы

Методы в этой группе влияют на вывод строки.

string.center(<width>[, <fill>]) выравнивает строку по центру.

s.center(<width>) возвращает строку, состоящую из s выровненной по ширине <width>. По умолчанию отступ состоит из пробела ASCII:

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

Если указан необязательный аргумент <fill>, он используется как символ заполнения:

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

Если s больше или равна <width>, строка возвращается без изменений:

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

string.expandtabs(tabsize=8) заменяет табуляции на пробелы

s.expandtabs() заменяет каждый символ табуляции ('\t') пробелами. По умолчанию табуляция заменяются на 8 пробелов:

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

tabsize необязательный параметр, задающий количество пробелов:

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

string.ljust(<width>[, <fill>]) выравнивание по левому краю строки в поле.

s.ljust(<width>) возвращает строку s, выравненную по левому краю в поле шириной <width>. По умолчанию отступ состоит из пробела ASCII:

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

Если указан аргумент <fill> , он используется как символ заполнения:

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

Если s больше или равна <width>, строка возвращается без изменений:

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

string.lstrip([<chars>]) обрезает пробельные символы слева

s. lstrip()возвращает копию s в которой все пробельные символы с левого края удалены:

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

Необязательный аргумент <chars>, определяет набор символов, которые будут удалены:

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

string.replace(<old>, <new>[, <count>]) заменяет вхождения подстроки в строке.

s.replace(<old>, <new>) возвращает копию s где все вхождения подстроки <old>, заменены на <new>:

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

Если указан необязательный аргумент <count>, выполняется количество <count> замен:

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

string.rjust(<width>[, <fill>]) выравнивание по правому краю строки в поле.

s.rjust(<width>) возвращает строку s, выравненную по правому краю в поле шириной <width>. По умолчанию отступ состоит из пробела ASCII:

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

Если указан аргумент <fill> , он используется как символ заполнения:

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

Если s больше или равна <width>, строка возвращается без изменений:

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

string.rstrip([<chars>]) обрезает пробельные символы справа

s.rstrip() возвращает копию s без пробельных символов, удаленных с правого края:

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

Необязательный аргумент <chars>, определяет набор символов, которые будут удалены:

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

string.strip([<chars>]) удаляет символы с левого и правого края строки.

s.strip() эквивалентно последовательному вызову s.lstrip()и s.rstrip(). Без аргумента <chars> метод удаляет пробелы в начале и в конце:

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

Как в .lstrip() и .rstrip(), необязательный аргумент <chars> определяет набор символов, которые будут удалены:

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

Важно: Когда возвращаемое значение метода является другой строкой, как это часто бывает, методы можно вызывать последовательно:

>>> '   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(<width>) дополняет строку нулями слева.

s.zfill(<width>) возвращает копию s дополненную '0' слева для достижения длины строки указанной в <width>:

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

Если s содержит знак перед цифрами, он остается слева строки:

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

Если s больше или равна <width>, строка возвращается без изменений:

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

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

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

Методы преобразование строки в список

Методы в этой группе преобразовывают строку в другой тип данных и наоборот. Эти методы возвращают или принимают итерируемые объекты — термин Python для последовательного набора объектов.

Многие из этих методов возвращают либо список, либо кортеж. Это два похожих типа данных, которые являются прототипами примеров итераций в python. Список заключен в квадратные скобки ( []), а кортеж заключен в простые (()).

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

string.join(<iterable>) объединяет список в строку.

s.join(<iterable>) возвращает строку, которая является результатом конкатенации объекта <iterable> с разделителем s.

Обратите внимание, что .join() вызывается строка-разделитель s . <iterable> должна быть последовательностью строковых объектов.

Примеры кода помогут вникнуть. В первом примере разделителем s является строка ', ', а <iterable> список строк:

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

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

В следующем примере <iterable> указывается как одно строковое значение. Когда строковое значение используется в качестве итерируемого, оно интерпретируется как список отдельных символов строки:

>>> list('corge')
['c', 'o', 'r', 'g', 'e']
>>> ':'.join('corge')
'c:o:r:g:e'

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

Этот пример завершается с ошибкой TypeError, потому что один из объектов в <iterable> не является строкой:

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

Это можно исправить так:

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

Как вы скоро увидите, многие объекты в Python можно итерировать, и .join() особенно полезен для создания из них строк.

string.partition(<sep>) делит строку на основе разделителя.

s.partition(<sep>) отделяет от s подстроку длиной от начала до первого вхождения <sep>. Возвращаемое значение представляет собой кортеж из трех частей:

Часть s до <sep>
Разделитель <sep>
Часть s после <sep>

Вот пара примеров .partition()в работе:

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

Если <sep> не найден в s, возвращаемый кортеж содержит s и две пустые строки:

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

s.rpartition(<sep>) делит строку на основе разделителя, начиная с конца.

s.rpartition(<sep>) работает как s.partition(<sep>), за исключением того, что s делится при последнем вхождении <sep> вместо первого:

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

string.rsplit(sep=None, maxsplit=-1) делит строку на список из подстрок.

Без аргументов s.rsplit() делит s на подстроки, разделенные любой последовательностью пробелов, и возвращает список:

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

Если <sep> указан, он используется в качестве разделителя:

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

Если <sep> = None, строка разделяется пробелами, как если бы <sep> не был указан вообще.

Когда <sep> явно указан в качестве разделителя s, последовательные повторы разделителя будут возвращены как пустые строки:

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

Это не работает, когда <sep> не указан. В этом случае последовательные пробельные символы объединяются в один разделитель, и результирующий список никогда не будет содержать пустых строк:

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

Если указан необязательный параметр <maxsplit>, выполняется максимальное количество разделений, начиная с правого края s:

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

Значение по умолчанию для <maxsplit> — -1. Это значит, что все возможные разделения должны быть выполнены:

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

string.split(sep=None, maxsplit=-1) делит строку на список из подстрок.

s.split() ведет себя как s.rsplit(), за исключением того, что при указании <maxsplit>, деление начинается с левого края s:

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

Если <maxsplit> не указано, между .rsplit() и .split() в python разницы нет.

string. splitlines([<keepends>]) делит текст на список строк.

s.splitlines() делит s на строки и возвращает их в списке. Любой из следующих символов или последовательностей символов считается границей строки:

Разделитель	Значение
\n	Новая строка
\r	Возврат каретки
\r\n	Возврат каретки + перевод строки
\v или же \x0b	Таблицы строк
\f или же \x0c	Подача формы
\x1c	Разделитель файлов
\x1d	Разделитель групп
\x1e	Разделитель записей
\x85	Следующая строка
\u2028	Новая строка (Unicode)
\u2029	Новый абзац (Unicode)

Вот пример использования нескольких различных разделителей строк:

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

Если в строке присутствуют последовательные символы границы строки, они появятся в списке результатов, как пустые строки:

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

Если необязательный аргумент <keepends> указан и его булевое значение True, то символы границы строк сохраняются в списке подстрок:

>>> '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']

Заключение

В этом руководстве было подробно рассмотрено множество различных механизмов, которые Python предоставляет для работы со строками, включая операторы, встроенные функции, индексирование, срезы и встроенные методы.

Python есть другие встроенные типы данных. В этих урока вы изучите два наиболее часто используемых:

Списки python
Кортежи (tuple)

41 вопрос о работе со строками в Python / Хабр

Я начал вести список наиболее часто используемых функций, решая алгоритмические задачи на LeetCode и HackerRank.

Быть хорошим программистом — это не значит помнить все встроенные функции некоего языка. Но это не означает и того, что их запоминание — бесполезное дело. Особенно — если речь идёт о подготовке к собеседованию.

Хочу сегодня поделиться со всеми желающими моей шпаргалкой по работе со строками в Python. Я оформил её в виде списка вопросов, который использую для самопроверки. Хотя эти вопросы и не тянут на полноценные задачи, которые предлагаются на собеседованиях, их освоение поможет вам в решении реальных задач по программированию.

1. Как проверить два объекта на идентичность?

Оператор is возвращает True в том случае, если в две переменные записана ссылка на одну и ту же область памяти. Именно об этом идёт речь при разговоре об «идентичности объектов».

Не стоит путать is и ==. Оператор == проверяет лишь равенство объектов.

animals           = ['python','gopher']
more_animals      = animals
print(animals == more_animals) #=> True
print(animals is more_animals) #=> True
even_more_animals = ['python','gopher']
print(animals == even_more_animals) #=> True
print(animals is even_more_animals) #=> False

Обратите внимание на то, что animals и even_more_animals не идентичны, хотя и равны друг другу.

Кроме того, существует функция id(), которая возвращает идентификатор адреса памяти, связанного с именем переменной. При вызове этой функции для двух идентичных объектов будет выдан один и тот же идентификатор.

name = 'object'
id(name)
#=> 4408718312

2. Как проверить то, что каждое слово в строке начинается с заглавной буквы?

Существует строковый метод istitle(), который проверяет, начинается ли каждое слово в строке с заглавной буквы.

print( 'The Hilton'.istitle() ) #=> True
print( 'The dog'.istitle() ) #=> False
print( 'sticky rice'.istitle() ) #=> False

3. Как проверить строку на вхождение в неё другой строки?

Существует оператор in, который вернёт True в том случае, если строка содержит искомую подстроку.

print( 'plane' in 'The worlds fastest plane' ) #=> True
print( 'car' in 'The worlds fastest plane' ) #=> False

4.

Как найти индекс первого вхождения подстроки в строку?

Есть два метода, возвращающих индекс первого вхождения подстроки в строку. Это — find() и index(). У каждого из них есть определённые особенности.

Метод find() возвращает -1 в том случае, если искомая подстрока в строке не найдена.

'The worlds fastest plane'.find('plane') #=> 19
'The worlds fastest plane'.find('car') #=> -1

Метод index() в подобной ситуации выбрасывает ошибку ValueError.

'The worlds fastest plane'.index('plane') #=> 19
'The worlds fastest plane'.index('car') #=> ValueError: substring not found

5. Как подсчитать количество символов в строке?

Функция len() возвращает длину строки.

len('The first president of the organization..') #=> 41

6.

Как подсчитать то, сколько раз определённый символ встречается в строке?

Ответить на этот вопрос нам поможет метод count(), который возвращает количество вхождений в строку заданного символа.

'The first president of the organization..'.count('o') #=> 3

7. Как сделать первый символ строки заглавной буквой?

Для того чтобы это сделать, можно воспользоваться методом capitalize().

'florida dolphins'.capitalize() #=> 'Florida dolphins'

8. Что такое f-строки и как ими пользоваться?

В Python 3.6 появилась новая возможность — так называемые «f-строки». Их применение чрезвычайно упрощает интерполяцию строк. Использование f-строк напоминает применение метода format().

При объявлении f-строк перед открывающей кавычкой пишется буква f.

name = 'Chris'
food = 'creme brulee'
f'Hello.  My name is {name} and I like {food}.'
#=> 'Hello. My name is Chris and I like creme brulee'

9. Как найти подстроку в заданной части строки?

Метод index() можно вызывать, передавая ему необязательные аргументы, представляющие индекс начального и конечного фрагмента строки, в пределах которых и нужно осуществлять поиск подстроки.

'the happiest person in the whole wide world.'.index('the',10,44)
#=> 23

Обратите внимание на то, что вышеприведённая конструкция возвращает 23, а не 0, как было бы, не ограничь мы поиск.

'the happiest person in the whole wide world.'.index('the')
#=> 0

10. Как вставить содержимое переменной в строку, воспользовавшись методом format()?

Метод format() позволяет добиваться результатов, сходных с теми, которые можно получить, применяя f-строки. Правда, я полагаю, что использовать format() не так удобно, так как все переменные приходится указывать в качестве аргументов format().

difficulty = 'easy'
thing = 'exam'
'That {} was {}!'.format(thing, difficulty)
#=> 'That exam was easy!'

11. Как узнать о том, что в строке содержатся только цифры?

Существует метод isnumeric(), который возвращает True в том случае, если все символы, входящие в строку, являются цифрами.

'80000'.isnumeric() #=> True

Используя этот метод, учитывайте то, что знаки препинания он цифрами не считает.

'1.0'.isnumeric() #=> False

12. Как разделить строку по заданному символу?

Здесь нам поможет метод split(), который разбивает строку по заданному символу или по нескольким символам.

'This is great'. split(' ')
#=> ['This', 'is', 'great']
'not--so--great'.split('--')
#=> ['not', 'so', 'great']

13. Как проверить строку на то, что она составлена только из строчных букв?

Метод islower() возвращает True только в том случае, если строка составлена исключительно из строчных букв.

'all lower case'.islower() #=> True
'not aLL lowercase'.islower() # False

14. Как проверить то, что строка начинается со строчной буквы?

Сделать это можно, вызвав вышеописанный метод islower() для первого символа строки.

'aPPLE'[0].islower() #=> True

15. Можно ли в Python прибавить целое число к строке?

В некоторых языках это возможно, но Python при попытке выполнения подобной операции будет выдана ошибка TypeError.

'Ten' + 10 #=> TypeError

16.

Как «перевернуть» строку?

Для того чтобы «перевернуть» строку, её можно разбить, представив в виде списка символов, «перевернуть» список, и, объединив его элементы, сформировать новую строку.

''.join(reversed("hello world"))
#=> 'dlrow olleh'

17. Как объединить список строк в одну строку, элементы которой разделены дефисами?

Метод join() умеет объединять элементы списков в строки, разделяя отдельные строки с использованием заданного символа.

'-'.join(['a','b','c'])
#=> 'a-b-c'

18. Как узнать о том, что все символы строки входят в ASCII?

Метод isascii() возвращает True в том случае, если все символы, имеющиеся в строке, входят в ASCII.

print( 'Â'.isascii() ) #=> False
print( 'A'.isascii() ) #=> True

19. Как привести всю строку к верхнему или нижнему регистру?

Для решения этих задач можно воспользоваться методами upper() и lower(), которые, соответственно, приводят все символы строк к верхнему и нижнему регистрам.

sentence = 'The Cat in the Hat'
sentence.upper() #=> 'THE CAT IN THE HAT'
sentence.lower() #=> 'the cat in the hat'

20. Как преобразовать первый и последний символы строки к верхнему регистру?

Тут, как и в одном из предыдущих примеров, мы будем обращаться к символам строки по индексам. Строки в Python иммутабельны, поэтому мы будем заниматься сборкой новой строки на основе существующей.

animal = 'fish'
animal[0].upper() + animal[1:-1] + animal[-1].upper()
#=> 'FisH'

21. Как проверить строку на то, что она составлена только из прописных букв?

Имеется метод isupper(), который похож на уже рассмотренный islower(). Но isupper() возвращает True только в том случае, если вся строка состоит из прописных букв.

'Toronto'.isupper() #=> False
'TORONTO'.isupper() #= True

22. В какой ситуации вы воспользовались бы методом splitlines()?

Метод splitlines() разделяет строки по символам разрыва строки.

sentence = "It was a stormy night\nThe house creeked\nThe wind blew."
sentence.splitlines()
#=> ['It was a stormy night', 'The house creeked', 'The wind blew.']

23. Как получить срез строки?

Для получения среза строки используется синтаксическая конструкция следующего вида:

string[start_index:end_index:step]

Здесь step — это шаг, с которым будут возвращаться символы строки из диапазона start_index:end_index. Значение step, равное 3, указывает на то, что возвращён будет каждый третий символ.

string = 'I like to eat apples'
string[:6] #=> 'I like'
string[7:13] #=> 'to eat'
string[0:-1:2] #=> 'Ilk oetape' (каждый 2-й символ)

24. Как преобразовать целое число в строку?

Для преобразования числа в строку можно воспользоваться конструктором str().

str(5) #=> '5'

25. Как узнать о том, что строка содержит только алфавитные символы?

Метод isalpha() возвращает True в том случае, если все символы в строке являются буквами.

'One1'.isalpha() #=> False
'One'.isalpha() #=> True

26. Как в заданной строке заменить на что-либо все вхождения некоей подстроки?

Если обойтись без экспорта модуля, позволяющего работать с регулярными выражениями, то для решения этой задачи можно воспользоваться методом replace().

sentence = 'Sally sells sea shells by the sea shore'
sentence.replace('sea', 'mountain')
#=> 'Sally sells mountain shells by the mountain shore'

27. Как вернуть символ строки с минимальным ASCII-кодом?

Если взглянуть на ASCII-коды элементов, то окажется, например, что прописные буквы имеют меньшие коды, чем строчные. Функция min() возвращает символ строки, имеющий наименьший код.

min('strings') #=> 'g'

28. Как проверить строку на то, что в ней содержатся только алфавитно-цифровые символы?

В состав алфавитно-цифровых символов входят буквы и цифры. Для ответа на этот вопрос можно воспользоваться методом isalnum().

'Ten10'.isalnum() #=> True
'Ten10.'.isalnum() #=> False

29. Как удалить пробелы из начала строки (из её левой части), из её конца (из правой части), или с обеих сторон строки?

Здесь нам пригодятся, соответственно, методы lstrip(), rstrip() и strip().

string = '  string of whitespace    '
string.lstrip() #=> 'string of whitespace    '
string.rstrip() #=> '  string of whitespace'
string.strip() #=> 'string of whitespace'

30. Как проверить то, что строка начинается с заданной последовательности символов, или заканчивается заданной последовательностью символов?

Для ответа на этот вопрос можно прибегнуть, соответственно, к методам startswith() и endswith().

city = 'New York'
city.startswith('New') #=> True
city.endswith('N') #=> False

31. Как закодировать строку в ASCII?

Метод encode() позволяет кодировать строки с использованием заданной кодировки. По умолчанию используется кодировка utf-8. Если некий символ не может быть представлен с использованием заданной кодировки, будет выдана ошибка UnicodeEncodeError.

'Fresh Tuna'.encode('ascii')
#=> b'Fresh Tuna'
'Fresh Tuna Â'.encode('ascii')
#=> UnicodeEncodeError: 'ascii' codec can't encode character '\xc2' in position 11: ordinal not in range(128)

32. Как узнать о том, что строка включает в себя только пробелы?

Есть метод isspace(), который возвращает True только в том случае, если строка состоит исключительно из пробелов.

''.isspace() #=> False
' '.isspace() #=> True
'   '. isspace() #=> True
' the '.isspace() #=> False

33. Что случится, если умножить некую строку на 3?

Будет создана новая строка, представляющая собой исходную строку, повторённую три раза.

'dog' * 3
# 'dogdogdog'

34. Как привести к верхнему регистру первый символ каждого слова в строке?

Существует метод title(), приводящий к верхнему регистру первую букву каждого слова в строке.

'once upon a time'.title() #=> 'Once Upon A Time'

35. Как объединить две строки?

Для объединения строк можно воспользоваться оператором +.

'string one' + ' ' + 'string two' 
#=> 'string one string two'

36. Как пользоваться методом partition()?

Метод partition() разбивает строку по заданной подстроке. После этого результат возвращается в виде кортежа. При этом подстрока, по которой осуществлялась разбивка, тоже входит в кортеж.

sentence = "If you want to be a ninja"
print(sentence.partition(' want '))
#=> ('If you', ' want ', 'to be a ninja')

37. Строки в Python иммутабельны. Что это значит?

То, что строки иммутабельны, говорит о том, что после того, как создан объект строки, он не может быть изменён. При «модификации» строк исходные строки не меняются. Вместо этого в памяти создаются совершенно новые объекты. Доказать это можно, воспользовавшись функцией id().

proverb = 'Rise each day before the sun'
print( id(proverb) )
#=> 4441962336
proverb_two = 'Rise each day before the sun' + ' if its a weekday'
print( id(proverb_two) )
#=> 4442287440

При конкатенации 'Rise each day before the sun' и ' if its a weekday' в памяти создаётся новый объект, имеющий новый идентификатор. Если бы исходный объект менялся бы, тогда у объектов был бы один и тот же идентификатор.

38. Если объявить одну и ту же строку дважды (записав её в 2 разные переменные) — сколько объектов будет создано в памяти? 1 или 2?

В качестве примера подобной работы со строками можно привести такой фрагмент кода:

animal = 'dog'
pet = 'dog'

При таком подходе в памяти создаётся лишь один объект. Когда я столкнулся с этим в первый раз, мне это не показалось интуитивно понятным. Но этот механизм помогает Python экономить память при работе с длинными строками.

Доказать это можно, прибегнув к функции id().

animal = 'dog'
print( id(animal) )
#=> 4441985688
pet = 'dog'
print( id(pet) )
#=> 4441985688

39. Как пользоваться методами maketrans() и translate()?

Метод maketrans() позволяет описать отображение одних символов на другие, возвращая таблицу преобразования.

Метод translate() позволяет применить заданную таблицу для преобразования строки.

# создаём отображение
mapping = str.maketrans("abcs", "123S")
# преобразуем строку
"abc are the first three letters".translate(mapping)
#=> '123 1re the firSt three letterS'

Обратите внимание на то, что в строке произведена замена символов a, b, c и s, соответственно, на символы 1, 2, 3 и S.

40. Как убрать из строки гласные буквы?

Один из ответов на этот вопрос заключается в том, что символы строки перебирают, пользуясь механизмом List Comprehension. Символы проверяют, сравнивая с кортежем, содержащим гласные буквы. Если символ не входит в кортеж — он присоединяется к новой строке.

string = 'Hello 1 World 2'
vowels = ('a','e','i','o','u')
''.join([c for c in string if c not in vowels])
#=> 'Hll 1 Wrld 2'

41.

В каких ситуациях пользуются методом rfind()?

Метод rfind() похож на метод find(), но он, в отличие от find(), просматривает строку не слева направо, а справа налево, возвращая индекс первого найденного вхождения искомой подстроки.

story = 'The price is right said Bob. The price is right.'
story.rfind('is')
#=> 39

Итоги

Я часто объясняю одному продакт-менеджеру, человеку в возрасте, что разработчики — это не словари, хранящие описания методов объектов. Но чем больше методов помнит разработчик — тем меньше ему придётся гуглить, и тем быстрее и приятнее ему будет работаться. Надеюсь, теперь вы без труда ответите на рассмотренные здесь вопросы.

Уважаемые читатели! Что, касающееся обработки строк в Python, вы посоветовали бы изучить тем, кто готовится к собеседованию?

Python: str() — работа со строками — Школа N61 г.

Ульяновска

`S = 'str'; S = "str"; S = '''str'''; S = """str"""`	Литералы строк
`S = "s\np\ta\nbbb"`	Экранированные последовательности
`S = r"C:\temp\new"`	Неформатированные строки (подавляют экранирование)
`S = b"byte"`	Строка байтов
`S1 + S2`	Конкатенация (сложение строк)
`S1 * 3`	Повторение строки
`S[i]`	Обращение по индексу
`S[i:j:step]`	Извлечение среза
`len(S)`	Длина строки
`S.find(str[, start[, end])`	Поиск подстроки в строке. Возвращает номер первого вхождения (индекс подстроки в строке) или -1
`S. rfind(str[, start[, end])`	Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
`S.index(str[, start[, end])`	Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
`S.rindex(str[, start[, end])`	Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
`S.replace(old, new[, num])`	Заменяет в строке S одну подстроку (old) на другую (new) num раз. Если num не указано, то заменить все вхождения old на new. Если num = 1, то заменить первое вхождение old на new. Если num = 3 — заменить первые 3 вхождения old на new.
`S.split([delimeter[, num]])`	разбивает строку на подстроки в зависимости от разделителя
`S.join(список)`	объединяет строки в одну строку, вставляя между ними определенный разделитель S
`S. isdigit()`	возвращает True, если все символы строки — цифры
`S.isnumeric()`	возвращает True, если строка представляет собой число
`S.isalpha()`	возвращает True, если строка состоит только из алфавитных символов
`S.isalnum()`	Состоит ли строка из цифр или букв
`S.islower()`	возвращает True, если строка состоит только из символов в нижнем регистре. Знаки препинания и цифры дают True.
`S.isupper()`	возвращает True, если все символы строки в верхнем регистре. Знаки препинания и цифры дают True.
`S.isspace()`	Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы (‘\f’), «новая строка» (‘\n’), «перевод каретки» (‘\r’), «горизонтальная табуляция» (‘\t’) и «вертикальная табуляция» (‘\v’))
`S. istitle()`	Возвращает True, если ВСЕ слова в строке начинаются с заглавной буквы
`S.startswith(str)`	Возвращает True, если строка начинается с подстроки str
`S.endswith(str)`	Возвращает True, если строка заканчивается на подстроку str
`S.capitalize()`	Переводит первый символ строки в верхний регистр, а все остальные в нижний
`S.upper()`	переводит строку в вехний регистр
`S.lower()`	переводит строку в нижний регистр
`S.title()`	начальные символы всех слов в строке переводятся в верхний регистр
`ord(символ)`	Символ в его код ASCII
`chr(число)`	Код ASCII в символ
`S.center(width, [fill])`	если длина строки меньше параметра width, то слева и справа от строки равномерно добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по центру
`S. count(str, [start],[end])`	Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
`S.expandtabs([tabsize])`	Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
`S.lstrip([chars])`	удаляет начальные пробелы из строки
`S.rstrip([chars])`	удаляет конечные пробелы из строки
`S.strip([chars])`	удаляет начальные и конечные пробелы из строки (удаление пробельных символов в начале и в конце строки). В параметре chars можно перечислить символы в любом порядке, которые следует удалить — удаляется символ, который присутствует в chars.
`S. partition(шаблон)`	Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
`S.rpartition(sep)`	Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
`S.swapcase()`	Переводит символы нижнего регистра в верхний, а верхнего — в нижний
`S.title()`	Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
`S.zfill(width)`	Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
`S.ljust(width, fillchar=" ")`	если длина строки меньше параметра width, то справа от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по левому краю
`S. rjust(width, fillchar=" ")`	если длина строки меньше параметра width, то слева от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по правому краю
`S.format(args, *kwargs)`	Форматирование строки

Задачник по Python. Тема 8. Работа со строками

Оглавление

Содержание

python / задачник

Тип данных: str

Контент: Вопросы (6шт) + задачи (6шт)

Предыдущая тема

Тема 7. Работа с множествами

Следующая тема

Тема 9. Условные
выражения

Оглавление

Введение

Рассмотрим строки как тип данных в Python. Опишем основные методы и свойства строк, необходимые для решения задач.

Перейти

Вопросы и ответы

6 вопросов по теме «Строки» + ответы

Перейти

Условия задач

6 задач по теме двух уровней сложности: Базовый и *Продвинутый

Перейти

Решения задач

Приводим код решений указанных выше задач

Перейти

Введение

Строки в языке питон являются неизменяемыми объектами. Это значит, что в момент запуска скрипта ячейка памяти, на которую ссылается строка, не меняется. Из этого следует, что символы этого типа данных не могут меняться или переприсваиваться.

Они поддерживают различные операторы, могут сравниваться, включают большое количество встроенных методов. Любые действия над строками не модифицируют их, а создают новый объект.

Для успешного решения заданий нужно повторить: срезы, методы строк, операции и основные свойства.

Вопросы по теме «Работа со строками»

Для того, чтобы приведенные в коде символы интерпретировались как строка, их нужно обернуть в кавычки. Имеется 4 способа это сделать:

– одинарные кавычки
– двойные кавычки
– тройные одинарные кавычки (многострочный текст с сохранением форматирования)
– тройные двойные кавычки (многострочный текст с сохранением форматирования)

Пример – Интерактивный режим
>>> ‘Одинарные кавычки’
‘Одинарные кавычки’
>>> «Двойные кавычки»
Двойные кавычки
>>> »’Тройные
одинарные
кавычки »’
‘Тройные \n одинарные \nкавычки ‘
>>> «»»
Тройные
двойные
кавычки»»»
‘\n Тройные \nдвойные \n\nкавычки’

Операция сложения или конкатенирования складывает две или более строк в одну. В качестве аргументов могут выступать только строки.

Пример – Интерактивный режим
>>> ‘Hello ‘ + ‘Py’
‘Hello Py’
>>> ‘Hello ‘ + 4
TypeError: can only concatenate str (not «int») to str

Операция умножения, применяемая к строкам, подразумевает ее дублирование определенное количество раз (в соответствии со значением числа, которое передано в качестве параметра. Если передать отрицательное число или ноль, то вернется пустая строка).

Пример – Интерактивный режим
>>> ‘Hello ‘ * 4
‘Hello Hello Hello Hello ‘
>>> ‘Hello ‘ * -4
»

Всё в питоне можно сделать строкой (так как все объекты имеют свойство __str__, первично унаследованное от прародителя всех классов object).

Поэтому любое число, список, объект или функцию можно представить в виде строки.

Пример – Интерактивный режим
>>> str(1. 11)
‘1.11’
>>> str(2 + 3j) # комплексное число
‘(2+3j)’
>>> str([2, 4, 8])
‘[2, 4, 8]’
>>> str({1: 100, 2: 200})
‘{1: 100, 2: 200}’
>>> str(sorted)
‘<built-in function sorted>’
>>> str(None)
‘None’

Не всегда приведение объекта к строке дает нам полезную информацию, но такая возможность имеется.

Метод encode() отображает строку в заданной кодировке. По умолчанию используется utf-8. Можно использовать и другие варианты кодировки, но при невозможности закодировать строку возникнет ошибка.

Пример – Интерактивный режим
>>> ‘cat’.encode(encoding=’ascii’)
b’cat’
>>> ‘кот’.encode(encoding=’utf-8′)
b’\xd0\xba\xd0\xbe\xd1\x82′
>>> ‘кот’.encode(encoding=’cp1251′)
b’\xea\xee\xf2′
>>> ‘кот’.encode(encoding=’utf32′)
b’\xff\xfe\x00\x00:\x04\x00\x00>\x04\x00\x00B\x04\x00\x00′
>>> ‘кот’. encode(encoding=’ascii’)
UnicodeEncodeError: ‘ascii’ codec can’t encode characters in position 0-2: ordinal not in range(128)

Срезы строк возвращают новый объект на основании переданных параметров.

В общем виде синтаксис следующий:

СТРОКА[начало:конец:шаг]

Параметры можно опускать, поддерживается и отрицательная индексация (с конца). При любых значениях индексов (даже за рамками длины строки) возвратится объект(в том числе пустой), и никогда не возникнет ошибка.

Шаг означает пропуски символов в строке: по умолчанию 1 – не пропускать символы, а, например, 3 – брать в срез только каждый третий элемент строки.

Отрицательный шаг берет символы в обратном порядке (от конца текста к началу).

Пример – Интерактивный режим
>>> ‘Это строка'[1]
‘т’
>>>’Это строка'[::2]
‘Эосрк’
>>>’Это строка'[::-1]
‘акортс отЭ’
>>> ‘Это строка'[1:4]
‘то ‘
>>> ‘Это строка'[:34:3]
‘Э ра’
>>> ‘Это строка'[-1:-4:-1]
‘ако’
>>> ‘Это строка'[:]
‘Это строка’

Согласно PEP-257 строка документации (docstring) — это одно- или многострочный строковый литерал, разделенный тройными одинарными кавычками в начале модуля, функции, класса, метода и описывающий, что делает этот объект.
Важное замечание: docstring может быть представлен только в тройных одинарных кавычках, независимо от того, расположен ли он в одной строке или на нескольких.
Почти все объекты (функции, классы, модули или методы) имеют описание, которое можно посмотреть. Для этого используется свойство __doc__.

Пример – Интерактивный режим
>>> import math
>>> math.__doc__
‘This module provides access to the mathematical functions\ndefined by the C standard.’
>>> math.sqrt.__doc__
‘Return the square root of x.’

Стоит отметить, что функция help() возвращает более полную информацию, нежели свойство __doc__.

При оформлении docstring принято пользоваться одним из 4-х шаблонов:
– NumPy
– PyDoc
– EpyDoc
– Google

Задачи по теме «Работа со строками»

Решение

Решения

Задача 1.

Базовый уровень
Условие
Напишите функцию search_substr(subst, st), которая принимает 2 строки и определяет, имеется ли подстрока subst в строке st. В случае нахождения подстроки, возвращается фраза «Есть контакт!», а иначе «Мимо!». Должно быть найдено совпадение независимо от регистра обеих строк.
Для решения задания необходимо воспользоваться строковыми методами lower() и find(). Стоит помнить, что find() возвращает -1 в случае ненахождения нужного элемента.
Решение – IDE
def search_substr(subst, st): if subst.lower() in st.lower(): return 'Есть контакт!' else: return 'Мимо!' # Тесты print(search_substr('Кол', 'коЛокОл')) print(search_substr('Колобок', 'колобоК')) print(search_substr('Кол', 'Плов'))
Результат выполнения
Есть контакт! Есть контакт! Мимо!
Задача 2.
Базовый уровень
Условие
Требуется определить индексы первого и последнего вхождения буквы в строке. Для этого нужно написать функцию first_last(letter, st), включающую 2 параметра: letter – искомый символ, st – целевая строка. В случае отсутствия буквы в строке, нужно вернуть кортеж (None, None), если же она есть, то кортеж будет состоять из первого и последнего индекса этого символа.
Решение задачи сводится к оперированию методами find() и rfind().
Решение — IDE
def first_last(letter, st): first = st.find(letter) if first < 0: return None, None last = st.rfind(letter) return first, last # Тесты print(first_last('a', 'abba')) print(first_last('a', 'abbaaaab')) print(first_last('a', 'a')) print(first_last('a', 'spring'))
Результат выполнения
(0, 3) (0, 6) (0, 0) (None, None)
Читайте также
Программирование на Python. Урок 4. Работа со строками
Строки в Python. Тип данных: str. Учимся выполнять основные действия над строковым типом данных в Python: создание, экранирование, конкатенация и умножение, срезы, форматирование, строковые методы.
Задача 3. Базовый уровень
Условие
На основании предоставленного отрывка текста определить 3 наиболее часто встречаемых символа в ней. Пробелы нужно игнорировать (не учитывать при подсчете). Для выведения результатов вычислений требуется написать функцию top3(st). Итог работы функции представить в виде строки: «символ – количество раз, символ – количество раз…».
Для простоты подсчета количества вхождений символов удобно использовать Counter из модуля collections.
Решение – IDE
from collections import Counter def top3(st): counter_top3 = Counter(st.replace(' ', '')).most_common(3) return ', '.join([f'{letter} - {cnt}' for letter, cnt in counter_top3]) # Тесты print(top3('Улыбкой ясною природа Сквозь сон встречает утро года Синея блещут небеса. Еще прозрачные, леса')) print(top3('АаА')) print(top3('Голова думала'))
Результат выполнения
е - 9, о - 8, р - 6 А - 2, а - 1 А - 3, о - 2, л - 2
Задача 4. *Продвинутый уровень
Условие
Николай решил вспомнить старые времена. В свое время было модно писать сообщения с чередующимися заглавной и малой буквами. Он захотел изобрести функцию, которая будет делать с любой предоставленной строкой аналогичное. Ваша задача: повторить труд студента camel(st) с учетом того, что пробелы и знаки препинания не должны портить чередование регистра символов (они в этом процессе не учитываются, но возвращаются в итоговой строке).
При помощи методов lower() и upper() проблема решается достаточно просто.
Решение — IDE
def camel(st): new_st = '' letter_counter = 0 for index, val in enumerate(st): if val.isalpha(): if letter_counter % 2 == 0: new_st += val. upper() else: new_st += val.lower() letter_counter += 1 else: new_st += val return new_st # Тесты print(camel('Утром!! было! солнечно!!!!')) print(camel('КРАСОТА)))')) print(camel('дождливЫЙ, вечеР??'))
И еще один вариант решения:
Решение — IDE
CASE_FUNCTIONS = [str.upper, str.lower] def camel(st): index = 0 camel_st = '' for sym in st: if sym.isalpha(): camel_st += CASE_FUNCTIONS[index % 2](sym) index += 1 else: camel_st += sym return camel_st # Тесты print(camel('Утром!! было! солнечно!!!!')) print(camel('КРАСОТА)))')) print(camel('дождливЫЙ, вечеР??'))
Результат выполнения
УтРоМ!! бЫлО! сОлНеЧнО!!!! КрАсОтА))) ДоЖдЛиВыЙ, вЕчЕр??
Задача 5.
* Продвинутый уровень
Условие
Дмитрий считает, что когда текст пишут в скобках (как вот тут, например), его читать не нужно. Вот и надумал он существенно укоротить время чтения, написав функцию, которая будет удалять все, что расположено внутри скобок. Помогите ленивому Диме разработать функцию shortener(st), которая будет удалять все, что внутри скобок и сами эти скобки, возвращая очищенный текст (скобки могут быть вложенными).
При разработке алгоритма решения нужно учесть, что самая последняя открывающая скобка должна обязательно иметь после себя закрывающую.
Решение — IDE
def shortener(st): while '(' in st or ')' in st: left = st.rfind('(') right = st.find(')', left) st = st.replace(st[left:right + 1], '') return st # Тесты print(shortener('Падал(лишнее (лишнее) лишнее) прошлогодний снег (лишнее)')) print(shortener('(лишнее(лишнее))Падал прошлогодний (лишнее(лишнее(лишнее)))снег'))
Результат выполнения
Падал прошлогодний снег Падал прошлогодний снег
Задача 6.
* Продвинутый уровень
Условие
Александр решил как-то отобразить в тексте BACKSPACE (т.е. удаление последнего символа). Он подумал, что символ «@» отлично для этого подходит. Всем своим знакомым он дал строки такого вида (например, «гр@оо@лк@оц@ва»), чтобы посмотреть, кому удастся написать функцию cleaned_str(st), возвращающую строку в ее чистом виде.
Так как у строк нет метода pop(), нужно сначала преобразовать их в список, а потом провести нужные манипуляции.
Решение — IDE
def cleaned_str(st): clean_lst = [] for symbol in st: if symbol == '@' and clean_lst: clean_lst.pop() elif symbol != '@': clean_lst.append(symbol) return ''.join(clean_lst) # Тесты print(cleaned_str('гр@оо@лк@оц@ва')) print(cleaned_str('сварка@@@@@лоб@ну@'))
Результат выполнения
голова слон
Предыдущая тема
Тема 7. Работа с множествами
Следующая тема
Тема 9. Условные
выражения
Как вам материал?
ПОКАЗАТЬ КОММЕНТАРИИ
Задачник. Программирование на Python.
Задачник по Python. Тема 2. Числа с плавающей точкой
Задачник по Python. Тема 3. Логический тип данных
Задачник по Python. Тема 5. Работа со словарями
Задачник по Python. Тема 7. Работа с множествами
Работа со строками в Python
На этой странице вы узнаете
Как заставить число не чувствовать себя как число?
Что будет, если взять символ, которого нет?
Почему “Не одно и то же” и “не одно и то же” — не одно и то же?
Человек – очень умное существо. Мы с вами умеем и читать, и писать.
Некоторые змеи, кстати, тоже. Не все, конечно, но Python – без проблем. У него для этого даже отдельный тип данных есть.
Определение строкового типа данных
Что такое строка в Python?
Строка — тип данных, хранящий в себе набор символов произвольной длины. .
При создании строк используются кавычки. Одинарные или двойные — можно использовать любые, главное, чтобы закрывающая и открывающая кавычка были одинаковыми.
Также для более удобного создания и изменения строк мы можем использовать следующие способы:
сложение строк (конкатенация) — получение новой строки, состоящей из двух других путем их “склеивания”;
умножение строки на число — когда нам нужна строка из повторяющихся элементов, строку, состоящую из этого элемента, можно умножить на количество повторений;
любой другой тип данных можно перевести в строковой с помощью команды str().
Как заставить число не чувствовать себя как число?
Загнать его в строку. Важно понимать, что число, записанное в строковом типе данных, будет восприниматься именно как строка. Поэтому стандартные математические операции к нему будут применены как к строке: вместо сложения произойдет конкатенация, а вместо умножения — многократное повторение строки.
Индексация
Индикация — это доступ к отдельным элементам чего-либо по индексу этого элемента — его порядкового номера. В Python индексация начинается с 0.
Каждый символ строки можно получить по индексу, указав после имени строки в квадратных скобках нужный индекс.
Важные моменты:
с помощью индекса можно, например, взять символ и записать его в отдельную переменную, но нельзя изменить;
индексы могут принимать и отрицательные значения. Это нужно для того, чтобы обращаться к символам строки не с начала, а с конца. Так, последний символ будет иметь индекс -1, у предпоследнего будет -2, у третьего с конца -3 и так далее.
Срез — это целая последовательность подряд идущих элементов, которую также можно достать с помощью индексов.
В квадратных скобках после имени строки указываются два значения через двоеточие — срезом будет последовательность символов, индексы границы которой — с первого значения включительно по второе не включительно.
Если какая-то из границ среза не указывается — программа будет считать началом среза начало или конец самой строки, если нет первого или последнего значения соответственно.
Основные строковые методы
Для упрощения работы со строками в Python есть достаточно много встроенных методов.
Какие есть встроенные функции для работы со строками?
len(s) — определяет длину строки s;
s.count(sub) — подсчитывает, сколько раз переданный элемент sub встречается в данной строке s;
s.split(sep) — делит строку s на части по разделителю sep. Если не указать разделитель, по умолчанию будет делить строку по пробелу. В качестве разделителя может быть указан любой символ или последовательность символов. Метод split создаст список, в котором будут части строки, разделенные по указанному значению.
s. replace(a, b, n) — возвращает измененное значение строки s, в которой элементы a заменены на b.
Последний параметр n является необязательным, если его не указать, то метод replace сразу поменяет все заменяемые значения а на b, какие только есть в строке. Если же его указать, то заменится ровно столько первых встретившихся элементов, сколько указано.
В том числе это удобный способ удаления чего-либо из строки, для этого в качестве аргумента b указываем пустую строку.
Перебор строк
Имея доступ к отдельным символам строки, мы имеем возможность их перебрать с помощью цикла for. И тут у нас есть два основных варианта:
Перебор по элементам. На каждом шаге цикла каждый новый элемент строки s будет записан в переменную i.
Такой подход удобен, когда нам не интересно взаимодействие соседних символов, так как к ним доступа у нас не будет. Но текущий символ мы можем проверить спокойно.
Например, из строки, состоящей из цифр, надо выписать только нечетные (у которых остаток от деления на 2 равен 1) — проверки отдельных элементов нам будет достаточно.
Перебор по индексам. Вариант реализации — с помощью диапазона range, в котором указана длина строки len(s). Тогда на каждом шаге цикла в переменную i будет записан индекс, по которому мы сможем обратиться к соответствующему элементу строки.
Такой вариант предпочтительнее, когда происходит что-то более интересное, и нам необходимо проверять или как-то использовать соседние символы, так как теперь у нас есть к ним доступ. Например, следующий за символом под индексом i будет иметь индекс i + 1, достать его не составит труда.
Для примера — из численной строки будем выводить пары соседних чисел, в которых они идут в порядке возрастания.
Что будет, если взять символ, которого нет?
Последний пример очень интересен, так как без должной внимательности мы имеем возможность наткнуться на ошибку типа “IndexError: string index out of range” — выход за границы строки.

Нельзя забывать, что в строке индексы начинаются с 0, поэтому в строке длиной 18 символов будут индексы от 0 до 17. И когда в переборе такой сроки по индексам мы дойдем до 17 и захотим проверить следующий для него i + 1, который уже будет равен 18, мы и получим эту ошибку.
Чтобы этого избежать, необходимо внимательно следить за обращением к индексам и учитывать, что за их границы выходить нельзя.
Оператор in
Оператор in проверяет наличие символа или последовательности символов в строке. Если искомый элемент есть в строке, оператор возвращает значение True, в противном случае — False.
Мы уже замечали оператор in, когда записывали цикл for, а теперь, зная о нем больше, можем применять его и в условных конструкциях.
letter = "f" sub = “ppa” word = "Floppa" if letter in word: print("Буква", letter, "есть в слове", word) else: print("Буквы", letter, "нет в слове", word) if sub in word: print("Последовательность", sub, "есть в слове", word) else: print("Последовательности", sub, "нет в слове", word) Вывод: Буквы f нет в слове Floppa Последовательность “ppa” есть в слове Floppa
Почему “Не одно и то же” и “не одно и то же” — не одно и то же?
Важно учитывать — строки чувствительны к регистру. В примере действительно нет буквы “f” — есть, такая же, но она заглавная, для Python это принципиально разные вещи.
Фактчек
Строка в Python — тип данных, хранящий в себе набор символов произвольной длины. Для создания строки используются двойные или одинарные кавычки.
Для обращения к отдельным символам строки используются индексы, для обращения к группе идущих подряд символов — срезы.
Для подсчета длины строки используется команда len, для подсчета вхождений элемента в строку — count, для разделения строки — split, для замены части строки — replace.
Если попытаться обратиться к индексу строки, которого не существует (например, к сотому элементу строки из 5 символов) — программа не заработает, выдавая ошибку типа IndexError.
Оператор in можно использовать для проверки нахождения элемента в строке.
Проверь себя
Задание 1.
Что может входить в состав строки?
Буквы латинского алфавита
Знаки препинания
Числа
Буквы русского алфавита
Все вышеперечисленное
Ничего из вышеперечисленного
Задание 2.
Результатом записи “100” + “2” * 4 будет…
108
10044
1002222
Это некорректно записанное выражение, выдаст ошибку
Задание 3.
При исходной строке s = “111222” в результате записи s = s.replace(“2”, “1”, 2) строка примет вид…
111112
221222
211222
222111
Задание 4.
В строке s = “13579qet” срез s[3:] будет равен…
Запись среза некорректна.
135
79qet
579qe
Задание 5.
Что означает вывод программы: “IndexError: string index out of range”?
Компьютер сломался, придется покупать новый
Строка содержит недопустимый символ, программа не может ее обработать
Произошел выход за границы индексов строки
Оператор in вернет это сообщение, если искомой последовательности нет в строке
Ответы: 1. — 5; 2. — 3; 3. — 1; 4. — 3; 5. — 3.
строк Python
❮ Предыдущая Далее ❯
Строки
Строки в Python заключаются либо в одинарные, либо в двойные кавычки.
«привет» — это то же самое, что и «привет».
Вы можете отобразить строковый литерал с помощью функции print() :
Пример
print(«Hello»)
print(‘Hello’)
Попробуйте сами »
Присвоить строку 90 переменной
Присвоение строки переменной выполняется с именем переменной, за которым следует знак равенства и строка:
Пример
a = «Hello»
print(a)
Попробуйте сами »
Многострочные строки
Вы можете назначить многострочную строку переменной, используя три кавычки:
Пример
три двойных кавычки:
a = «»»Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut Labore et dolore magna aliqua. «»»
print(a)
Попробуйте сами »
Или три одинарных кавычки:
Пример
a = »’Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut Labore et dolore magna aliqua.»’
print(a)
Попробуйте сами »
Примечание: в результате разрывы строк вставляются в том же месте, что и в коде.
Строки — это массивы
Как и во многих других популярных языках программирования, строки в Python представляют собой массивы байтов, представляющих символы Юникода.
Однако в Python нет символьного типа данных, один символ представляет собой просто строку длиной 1.
Для доступа к элементам строки можно использовать квадратные скобки.
Пример
Получить символ в позиции 1 (помните, что первый символ имеет позиция 0):
a = «Привет, мир!»
print(a[1])
Попробуйте сами »
Перебор строки в цикле
Поскольку строки являются массивами, мы можем перебирать символы в строке с помощью для цикла .
Пример
Прокрутите буквы в слове «банан»:
вместо x в «банане»:
print(x)
Попробуйте сами »
Узнайте больше о циклах For в нашей главе Python For Loops.
Длина строки
Чтобы получить длину строки, используйте функцию len() .
Пример
Функция len() возвращает длину строки:
a = «Hello, World!»
print(len(a))
Попробуйте сами »
Проверить строку
Чтобы проверить, присутствует ли в строке определенная фраза или символ, мы можем использовать ключевое слово в .
Пример
Проверьте, присутствует ли слово «бесплатно» в следующем тексте:
txt = «Лучшее в жизни — бесплатно!»
print(«бесплатно» в txt)
Попробуйте сами »
Используйте в операторе if :
Пример
Печатать, только если присутствует «бесплатно»:
txt = «Лучшее в жизни бесплатно!»
если «бесплатно» в txt:
print(«Да, ‘бесплатно’ присутствует. «)
Попробуйте сами »
Узнайте больше об операторах If в нашем Python Если…иначе глава.
Проверить, НЕ
Чтобы проверить, НЕ присутствует ли в строке определенная фраза или символ, мы можем использовать ключевое слово не в .
Пример
Проверьте, НЕ присутствует ли слово «дорого» в следующем тексте:
txt = «Лучшие вещи в жизни бесплатны!»
print(«дорого» не в txt)
Попробуйте сами »
Используйте в операторе if :
в жизни свободны!»

если «дорого» не в txt:
print(«Нет, ‘дорого’ НЕТ.»)
Попробуйте сами »
❮ Предыдущая Далее ❯

NEW
Мы только что запустили
Видео W3Schools
Узнать
ПИКЕР ЦВЕТА
КОД ИГРЫ
Играть в игру
Top Tutorials
Учебное пособие по HTML
Учебное пособие по CSS
Учебное пособие по JavaScript
Учебное пособие
Учебное пособие по SQL
Учебное пособие по Python
Учебное пособие по W3. CSS
Учебное пособие по Bootstrap
Учебное пособие по PHP
Учебное пособие по Java
Учебное пособие по C++
Учебное пособие по jQuery
Top 9019
9003 900 Справочник по HTML
Справочник по CSS
Справочник по JavaScript
Справочник по SQL
Справочник по Python
Справочник по W3.CSS
Справочник по Bootstrap
Справочник по PHP
Цвета HTML
Справочник по Java
Справочник по Angular
Справочник по jQuery
Лучшие примеры
Примеры HTML
Примеры CSS
Примеры JavaScript
Примеры инструкций
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery
FORUM | О
W3Schools оптимизирован для обучения и обучения. Примеры могут быть упрощены для улучшения чтения и обучения. Учебники, ссылки и примеры постоянно пересматриваются, чтобы избежать ошибок, но мы не можем гарантировать полную правильность всего содержания. Используя W3Schools, вы соглашаетесь прочитать и принять наши условия использования, куки-файлы и политика конфиденциальности.
Copyright 1999-2022 Refsnes Data. Все права защищены.
W3Schools работает на основе W3.CSS.
строк и символьных данных в Python — настоящий Python

В учебном пособии по основным типам данных в Python вы узнали, как определить строки: объектов, содержащих последовательности символьных данных. Обработка данных символов является неотъемлемой частью программирования. Это редкое приложение, которому не нужно манипулировать строками хотя бы в некоторой степени.
Вот что вы узнаете из этого руководства: Python предоставляет богатый набор операторов, функций и методов для работы со строками. Когда вы закончите работу с этим учебным пособием, вы будете знать, как получать доступ к частям строк и извлекать их, а также будете знакомы с методами, которые доступны для манипулирования строковыми данными и их изменения.

+
Оператор + объединяет строки. Он возвращает строку, состоящую из объединенных операндов, как показано здесь:
>>>
>>> с = 'фу' >>> т = 'бар' >>> у = 'баз' >>> с + т 'фубар' >>> с + т + и 'фубарбаз' >>> print('Команда вперед' + '!!!') Вперёд команда!!!
Оператор
*
Оператор * создает несколько копий строки. Если s является строкой, а n является целым числом, любое из следующих выражений возвращает строку, состоящую из n конкатенированных копий s :
с * п
п * с
Вот примеры обеих форм:
>>>
>>> s = 'foo.' >>> с * 4 'фу.фу.фу.фу.' >>> 4*с 'фу.фу.фу.фу.'
Операнд множителя n должен быть целым числом. Вы могли бы подумать, что это должно быть положительное целое число, но забавно, что оно может быть нулевым или отрицательным, и в этом случае результатом будет пустая строка:
.
>>>
>>> 'фу' * -8 ''
Если бы вы создали строковую переменную и инициализировали ее пустой строкой, присвоив ей значение 'foo' * -8 , любой бы справедливо подумал, что вы немного не в себе. Но это сработает.
в Оператор
Python также предоставляет оператор принадлежности, который можно использовать со строками. Оператор в возвращает True , если первый операнд содержится во втором, и False в противном случае:
>>>
>>> с = 'фу' >>> s в «Это пища для размышлений». Истинный >>> s в "Это хорошо на данный момент". ЛОЖЬ
Существует также оператор не в , который делает обратное:
>>>
>>> 'z' не в 'abc' Истинный >>> 'z' не в 'xyz' ЛОЖЬ
Встроенные строковые функции
Как вы видели в учебнике по основным типам данных в Python, Python предоставляет множество функций, встроенных в интерпретатор и всегда доступных. Вот некоторые из них, которые работают со строками:
Функция Описание
хр() Преобразует целое число в символ
порядок() Преобразует символ в целое число
лен() Возвращает длину строки
стр() Возвращает строковое представление объекта
Более подробно они рассматриваются ниже.
орд(с)
Возвращает целочисленное значение для данного символа.
На самом базовом уровне компьютеры хранят всю информацию в виде чисел. Для представления символьных данных используется схема перевода, которая сопоставляет каждый символ с его репрезентативным номером.
Простейшая широко используемая схема называется ASCII. Он охватывает распространенные латинские символы, с которыми вы, вероятно, больше всего привыкли работать. Для этих символов ord(c) возвращает значение ASCII для символа c :
>>>
>>> порядок('а') 97 >>> порядок('#') 35
ASCII хорош, насколько это возможно. Но в мире используется много разных языков и бесчисленное количество символов и глифов, которые появляются в цифровых медиа. Полный набор символов, которые потенциально могут потребоваться для представления в компьютерном коде, намного превосходит обычные латинские буквы, цифры и символы, которые вы обычно видите.
Unicode — амбициозный стандарт, который пытается предоставить числовой код для каждого возможного символа на всех возможных языках и на каждой возможной платформе. Python 3 широко поддерживает Unicode, в том числе позволяет использовать символы Unicode в строках.
Пока вы остаетесь в области общих символов, практическая разница между ASCII и Unicode незначительна. Но функция ord() также будет возвращать числовые значения для символов Unicode:
>>>
>>> ord('€') 8364 >>> порядок('∑') 8721
хр(н)
Возвращает символьное значение для заданного целого числа.
chr() делает обратное ord() . Учитывая числовое значение n , chr(n) возвращает строку, представляющую символ, который соответствует n :
>>>
>>> хр(97) а >>> хр(35) '#'
chr() также обрабатывает символы Unicode:
>>>
>>> хр(8364) '€' >>> хр(8721) '∑'
лен(ы)
Возвращает длину строки.
С помощью len() вы можете проверить длину строки Python. len(s) возвращает количество символов в s :
>>>
>>> s = 'Я строка.' >>> Лен(ы) 14
ул(объект)
Возвращает строковое представление объекта.
Практически любой объект в Python может быть представлен в виде строки. str(obj) возвращает строковое представление объекта obj :
>>>
>>> ул(49.2) «49,2» >>> ул(3+4j) '(3+4j)' >>> ул(3 + 29) '32' >>> ул('фу') 'фу'

В Python строки представляют собой упорядоченные последовательности символьных данных, поэтому их можно индексировать таким образом. Доступ к отдельным символам в строке можно получить, указав имя строки, за которым следует число в квадратных скобках ( [] ).
Строковые индексы
Доступ к отдельным символам можно получить по индексу следующим образом:
>>>
>>> s = 'foobar' >>> с[0] 'ф' >>> с[1] 'о' >>> с[3] 'б' >>> Лен(ы) 6 >>> с[лен(ы)-1] 'р'
Попытка проиндексировать за конец строки приводит к ошибке:
>>>
>>> с[6] Traceback (последний последний вызов): Файл "", строка 1, в с[6] IndexError: индекс строки вне допустимого диапазона
Строковые индексы также могут быть указаны с отрицательными числами, и в этом случае индексирование происходит от конца строки назад: -1 относится к последнему символу, -2 к предпоследнему символу и так далее. Вот та же диаграмма, показывающая как положительные, так и отрицательные индексы в строке 'фубар' :
Положительные и отрицательные строковые индексы
Вот несколько примеров отрицательного индексирования:
>>>
>>> s = 'foobar' >>> с[-1] 'р' >>> с[-2] а >>> Лен(ы) 6 >>> с[-лен(ы)] 'ф'
Попытка проиндексировать отрицательные числа за пределами начала строки приводит к ошибке:
>>>
>>> с[-7] Traceback (последний последний вызов): Файл "", строка 1, в с[-7] IndexError: индекс строки вне допустимого диапазона
Для любой непустой строки s , s[len(s)-1] и s[-1] возвращают последний символ. Нет никакого индекса, который имел бы смысл для пустой строки.
Нарезка струн
Python также допускает форму синтаксиса индексации, которая извлекает подстроки из строки, известную как нарезка строки. Если s является строкой, выражение вида s[m:n] возвращает часть s , начиная с позиции m и до, но не включая позицию n :
>>>
>>> s = 'foobar' >>> с[2:5] 'оба'
Помните: Строковые индексы отсчитываются от нуля. Первый символ в строке имеет индекс 0 . Это относится как к стандартной индексации, так и к нарезке.
Опять же, второй индекс указывает первый символ, который не включен в результат — символ 'r' ( s[5] ) в приведенном выше примере. Это может показаться немного неинтуитивным, но оно приводит к такому результату, который имеет смысл: выражение s[m:n] вернет подстроку длиной n - m символов, в данном случае 5 - 2 = 3 .
Если вы опустите первый индекс, срез начнется с начала строки. Таким образом, s[:m] и s[0:m] эквивалентны:
>>>
>>> s = 'foobar' >>> с[:4] 'фоб' >>> с[0:4] 'фоб'
Аналогично, если вы опустите второй индекс, как в s[n:] , срез будет простираться от первого индекса до конца строки. Это хорошая, лаконичная альтернатива более громоздкому 9.0012 с[н:длина(ы)] :
>>>
>>> s = 'foobar' >>> с[2:] 'обар' >>> с[2:длина(ы)] 'обар'
Для любой строки s и любого целого числа n ( 0 ≤ n ≤ len(s) ), s[:n] + s[n:] будет равно s :
>>>
>>> s = 'foobar' >>> с[:4] + с[4:] 'фубар' >>> с[:4] + с[4:] == с Истинный
Если не указывать оба индекса, возвращается исходная строка целиком. Буквально. Это не копия, это ссылка на исходную строку:
>>>
>>> s = 'foobar' >>> т = с[:] >>> идентификатор(а) 59598496 >>> идентификатор(т) 59598496 >>> с это т Истинный
Если первый индекс в срезе больше или равен второму индексу, Python возвращает пустую строку. Это еще один запутанный способ генерировать пустую строку, если вы ее искали:
.
>>>
>>> с[2:2] '' >>> с[4:2] ''
Отрицательные индексы также могут использоваться при нарезке. -1 относится к последнему символу, -2 — к предпоследнему и т. д., как и при простой индексации. На приведенной ниже диаграмме показано, как выделить подстроку 'oob' из строки 'foobar' , используя как положительные, так и отрицательные индексы:
Разрезание строк с положительными и отрицательными индексами
Вот соответствующий код Python:
>>>
>>> s = 'foobar' >>> с[-5:-2] 'ооб' >>> с[1:4] 'ооб' >>> с[-5:-2] == с[1:4] Истинный

Есть еще один вариант синтаксиса нарезки для обсуждения. Добавление дополнительных : и третьего индекса обозначает шаг (также называемый шагом), который указывает, на сколько символов нужно перейти после получения каждого символа в срезе.
Индексация строки с помощью Stride
Аналогично, 1:6:2 задает срез, начинающийся со второго символа (индекс 1 ) и заканчивающийся последним символом, и снова значение шага 2 приводит к тому, что каждый второй символ пропускается. :
Индексация другой строки с помощью Stride
Здесь показан иллюстративный код REPL:
>>>
>>> s = 'foobar' >>> с[0:6:2] 'фоа' >>> с[1:6:2] 'обр'
Как и при любой нарезке, первый и второй индексы можно опустить, а по умолчанию использовать первый и последний символы соответственно:
>>>
>>> с = '12345' * 5 >>> с '1234512345123451234512345' >>> с[::5] '11111' >>> с[4::5] '55555'
Вы также можете указать отрицательное значение шага, и в этом случае Python выполняет шаг назад по строке. В этом случае начальный/первый индекс должен быть больше конечного/второго индекса:
.
>>>
>>> s = 'foobar' >>> с[5:0:-2] 'рбо'
В приведенном выше примере 5:0:-2 означает «начать с последнего символа и сделать шаг назад на 2 до первого символа, но не включая его».
При переходе назад, если первый и второй индексы опущены, значения по умолчанию интуитивным образом меняются местами: первый индекс по умолчанию устанавливается в конец строки, а второй индекс — в начало. Вот пример:
>>>
>>> с = '12345' * 5 >>> с '1234512345123451234512345' >>> с[::-5] '55555'
Это общая парадигма обращения строки:
>>>
>>> s = 'Если это говорит товарищ Наполеон, значит, это правильно'. >>> с[::-1] '.thgir eb tsum ti ,ti syas noelopaN edarmoc fI'
Интерполяция переменных в строку
В Python версии 3. 6 был представлен новый механизм форматирования строк. Эта функция официально называется Formatted String Literal, но чаще упоминается по псевдониму f-string 9.0065 .
Возможности форматирования, предоставляемые f-строками, обширны и не будут подробно рассматриваться здесь. Если вы хотите узнать больше, вы можете ознакомиться со статьей Real Python Python 3’s f-Strings: An Improved String Formatting Syntax (Guide). Позже в этой серии появится учебник по форматированному выводу, в котором более подробно рассматриваются f-строки.
Одна простая функция f-строк, которую вы можете начать использовать прямо сейчас, — это переменная интерполяция. Вы можете указать имя переменной непосредственно в литерале f-строки, и Python заменит это имя соответствующим значением.
Например, предположим, что вы хотите отобразить результат арифметического вычисления. Вы можете сделать это с помощью простого оператора print() , разделяя числовые значения и строковые литералы запятыми:
>>>
>>> n = 20 >>> м = 25 >>> произведение = п * м >>> print('Произведение', n, 'и', m, 'есть', prod) Произведение 20 и 25 равно 500.
Но это громоздко. Чтобы сделать то же самое, используя f-строку:
Укажите f в нижнем регистре или F в верхнем регистре непосредственно перед открывающей кавычкой строкового литерала. Это говорит Python, что это f-строка, а не стандартная строка.
Укажите любые переменные для интерполяции в фигурных скобках ( {} ).
Повторное преобразование с использованием f-строки, приведенный выше пример выглядит намного чище:
>>>
>>> n = 20 >>> м = 25 >>> произведение = п * м >>> print(f'Произведение {n} и {m} равно {prod}') Произведение 20 и 25 равно 500.
Для определения f-строки можно использовать любой из трех механизмов кавычек Python:
>>>
>>> var = 'Кора' >>> print(f'Собака говорит {var}!') Собака говорит Лай! >>> print(f"Собака говорит {var}!") Собака говорит Лай! >>> print(f'''Собака говорит {var}!''') Собака говорит Лай!

Короче говоря, вы не можете. Строки — это один из типов данных, которые Python считает неизменяемыми, то есть не подлежащими изменению. На самом деле все типы данных, которые вы видели до сих пор, являются неизменяемыми. (В Python действительно предусмотрены изменяемые типы данных, как вы скоро увидите.)
По правде говоря, нет особой необходимости изменять строки. Обычно вы можете легко выполнить то, что хотите, создав копию исходной строки, в которой есть желаемое изменение. В Python есть очень много способов сделать это. Вот один из вариантов:
Методы аналогичны функциям. Метод — это специализированный тип вызываемой процедуры, тесно связанной с объектом. Как и функция, метод вызывается для выполнения отдельной задачи, но он вызывается для определенного объекта и во время выполнения получает информацию о своем целевом объекте.
Вы узнаете гораздо больше об определении и вызове методов позже при обсуждении объектно-ориентированного программирования. На данный момент цель состоит в том, чтобы представить некоторые из наиболее часто используемых встроенных методов, которые Python поддерживает для работы со строковыми объектами.
Каждый метод в этой группе поддерживает необязательные <начало> и <конец> аргументов. Они интерпретируются как нарезка строки: действие метода ограничено частью целевой строки, начинающейся с позиции символа и продолжающейся до позиции символа , но не включая ее. Если указано, а — нет, метод применяется к части целевой строки от до конца строки.
Примечание: Вот как документация Python описывает .istitle() , на случай, если вы сочтете это более интуитивным: «Символы верхнего регистра могут следовать только за символами без регистра, а символы нижнего регистра — только за символами в регистре».
. >>> >>> 'foo'. center(10) 'фу' Если указан необязательный аргумент , он используется в качестве символа заполнения: >>> >>> 'бар'.center(10, '-') '---бар----' Если s уже не меньше длины , возвращается без изменений: >>> >>> 'foo'.center(2) 'фу' s.expandtabs(размер вкладки=8) Разворачивает вкладки в строке. s.expandtabs() заменяет каждый символ табуляции ( '\t' ) пробелами. По умолчанию пробелы заполняются с учетом позиции табуляции в каждом восьмом столбце: . >>> >>> 'a\tb\tc'.expandtabs() 'а б в' >>> 'aaa\tbbb\tc'.expandtabs() 'ааа ббб с' tabsize — необязательный параметр ключевого слова, указывающий альтернативные столбцы табуляции: >>> >>> 'a\tb\tc'. expandtabs(4) 'а б в' >>> 'aaa\tbbb\tc'.expandtabs(tabsize=4) 'ааа ббб с' s.ljust(<ширина>[ <заполнение>]) Выравнивает строку в поле по левому краю. s.ljust() возвращает строку, состоящую из s с выравниванием по левому краю в поле шириной . По умолчанию заполнение состоит из символа пробела ASCII: . >>> >>> 'foo'.ljust(10) 'фу' Если указан необязательный аргумент , он используется в качестве символа заполнения: >>> >>> 'foo'.ljust(10, '-') 'фу-------' Если s уже не меньше длины , возвращается без изменений: >>> >>> 'foo'.ljust(2) 'фу' s.lstrip([<символы>]) Удаляет начальные символы из строки. s.lstrip() возвращает копию s с удалением любых пробельных символов с левого конца: >>> >>> ' foo bar baz '.lstrip() 'фу бар баз' >>> '\t\nfoo\t\nbar\t\nbaz'.lstrip() 'фу\т\нбар\т\нбаз' Если указан необязательный аргумент <символы> , это строка, указывающая набор удаляемых символов: >>> >>> 'http://www.realpython.com'.lstrip('/:pth') 'www.realpython.com' s.replace(<старый>, <новый>[ <число>]) Заменяет вхождения подстроки в строке. В Python для удаления символа из строки можно использовать метод Python string .replace() . s.replace(, ) возвращает копию s со всеми вхождениями подстроки замененной на : >>> >>> 'foo bar foo baz foo qux'. replace('foo', 'grault') 'граулт бар граулт баз граулт квкс' Если указан необязательный аргумент , выполняется максимум замен, начиная с левого конца s : >>> >>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2) 'граулт бар граулт баз фу кукс' s.rjust(<ширина>[ <заполнение>]) Выравнивает строку в поле по правому краю. s.rjust(<ширина>) возвращает строку, состоящую из s , выровненную по правому краю в поле шириной . По умолчанию заполнение состоит из символа пробела ASCII: . >>> >>> 'foo'.rjust(10) 'фу' Если указан необязательный аргумент , он используется в качестве символа заполнения: >>> >>> 'foo'. rjust(10, '-') '-------фу' Если s уже не меньше , возвращается без изменений: >>> >>> 'foo'.rjust(2) 'фу' s.rstrip([]) Обрезает конечные символы строки. s.rstrip() возвращает копию s с удаленными пробелами с правого конца: >>> >>> ' foo bar baz '.rstrip() "фу бар баз" >>> 'foo\t\nbar\t\nbaz\t\n'.rstrip() 'фу\т\нбар\т\нбаз' Если указан необязательный аргумент <символы> , это строка, указывающая набор удаляемых символов: >>> >>> 'foo.$$$;'.rstrip(';$.') 'фу' s.strip([<символы>]) Удаляет символы с левого и правого концов строки. s.strip() по существу эквивалентен последовательному вызову s. lstrip() и s.rstrip() . Без <символы> аргумент, он удаляет начальные и конечные пробелы: >>> >>> s = 'foo bar baz\t\t\t' >>> s = s.lstrip() >>> s = s.rstrip() >>> с 'фу бар баз' Как и в случае с .lstrip() и .rstrip() , необязательный аргумент указывает набор символов, которые нужно удалить: >>> >>> 'www.realpython.com'.strip('w.moc') «настоящий питон» Примечание: Когда возвращаемым значением строкового метода является другая строка, как это часто бывает, методы можно вызывать последовательно, объединяя вызовы в цепочку: >>> >>> ' foo bar baz\t \t\t'.lstrip().rstrip() 'фу бар баз' >>> ' foo bar baz\t\t\t'.strip() 'фу бар баз' >>> 'www.realpython.com'.lstrip('w.moc').rstrip('w.moc') «настоящий питон» >>> 'www. realpython.com'.strip('w.moc') «настоящий питон» s.zfill(<ширина>) Дополняет строку слева нулями. s.zfill() возвращает копию s с левым дополнением '0' символов до указанного : >>> >>> '42'.zfill(5) '00042' Если s содержит начальный знак, он остается на левом краю строки результата после вставки нулей: >>> >>> '+42'.zfill(8) '+0000042' >>> '-42'.zfill(8) '-0000042' Если s уже не меньше длины , возвращается без изменений: >>> >>> '-42'.zfill(3) '-42' .zfill() наиболее удобен для строкового представления чисел, но Python все равно с радостью дополнит нулями строку, которая не является: >>> >>> 'foo'. zfill(6) '000foo' Преобразование между строками и списками Методы этой группы преобразуют строку в некоторый составной тип данных, либо склеивая объекты вместе для создания строки, либо разбивая строку на части. Эти методы работают или возвращают итерируемых объекта , общий термин Python для последовательного набора объектов. Вы более подробно изучите внутреннюю работу итерируемых объектов в следующем руководстве по определенной итерации. Многие из этих методов возвращают либо список, либо кортеж. Это два похожих составных типа данных, которые являются прототипами итерируемых объектов в Python. Они рассматриваются в следующем уроке, так что скоро вы узнаете о них! До тех пор просто думайте о них как о последовательностях значений. Список заключен в квадратные скобки ( [] ), а кортеж заключен в круглые скобки ( () ). После этого введения давайте взглянем на последнюю группу строковых методов. s.join(<итерируемый>) Объединяет строки из итерируемого объекта. s.join() возвращает строку, полученную в результате объединения объектов в , разделенных s . Обратите внимание, что .join() вызывается для s , строки разделителя. также должен быть последовательностью строковых объектов. Пример кода должен помочь прояснить ситуацию. В следующем примере разделитель s — это строка ', ' и — список строковых значений: >>> >>> ', '.join(['foo', 'bar', 'baz', 'qux']) 'фу, бар, баз, квс' Результатом является одна строка, состоящая из объектов списка, разделенных запятыми. В следующем примере указывается как одно строковое значение. Когда строковое значение используется как итерируемый объект, оно интерпретируется как список отдельных символов строки: . >>> >>> список('корж') ['с', 'о', 'р', 'г', 'е'] >>> ':'.join('corge') 'к: о: г: г: е' Таким образом, результатом ':'.join('corge') является строка, состоящая из всех символов 'corge' , разделенных ':' . Этот пример завершается ошибкой, так как один из объектов в не является строкой: >>> >>> '---'.join(['foo', 23, 'bar']) Traceback (последний последний вызов): Файл "", строка 1, в '---'.join(['foo', 23, 'bar']) TypeError: элемент последовательности 1: ожидаемый экземпляр str, int найден Но это поправимо: >>> >>> '---'.join(['foo', str(23), 'bar']) 'фу---23---бар' Как вы скоро увидите, многие составные объекты в Python можно рассматривать как итерируемые, и . join() особенно полезен для создания из них строк. s.partition() Разделяет строку на основе разделителя. s.partition() разбивает s при первом появлении строки . Возвращаемое значение представляет собой кортеж из трех частей, состоящий из: Часть s предшествующая сам Часть s , следующая за Вот пара примеров .partition() в действии: >>> >>> 'foo.bar'.partition('.') («фу», «.», «бар») >>> 'foo@@bar@@baz'.partition('@@') ('foo', '@@', 'bar@@baz') Если <сен> не найден в s , возвращенный кортеж содержит s , за которыми следуют две пустые строки: >>> >>> 'foo. bar'.partition('@@') ('foo.bar', '', '') Помните: Списки и кортежи рассматриваются в следующем руководстве. s.rpartition() Разделяет строку на основе разделителя. s.rpartition() работает точно так же, как s.partition() , за исключением того, что s разбивается на последнее вхождение вместо первого вхождения: >>> >>> 'foo@@bar@@baz'.partition('@@') ('foo', '@@', 'bar@@baz') >>> 'foo@@bar@@baz'.rpartition('@@') ('foo@@bar', '@@', 'баз') s.rsplit(sep=Нет, maxsplit=-1) Разбивает строку на список подстрок. Без аргументов, s.rsplit() разбивает s на подстроки, разделенные любой последовательностью пробелов, и возвращает подстроки в виде списка: >>> >>> 'foo bar baz qux'. rsplit() ['фу', 'бар', 'баз', 'кукс'] >>> 'foo\n\tbar baz\r\fqux'.rsplit() ['фу', 'бар', 'баз', 'кукс'] Если указано , оно используется как разделитель для разделения: >>> >>> 'foo.bar.baz.qux'.rsplit(sep='.') ['фу', 'бар', 'баз', 'кукс'] (Если указано со значением None , строка разделяется пробелами, как если бы вообще не было указано.) Когда явно указан как разделитель, предполагается, что последовательные разделители в s разделяют пустые строки, которые будут возвращены: >>> >>> 'foo...bar'.rsplit(sep='.') ['фу', '', '', 'бар'] Однако это не тот случай, когда опущен. В этом случае последовательные пробельные символы объединяются в один разделитель, и результирующий список никогда не будет содержать пустых строк: >>> >>> 'foo\t\t\tbar'. rsplit() ['фу', 'бар'] Если указан необязательный параметр ключевого слова , выполняется максимальное количество разделений, начиная с правого конца с : >>> >>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1) ['www.realpython', 'com'] Значение по умолчанию для равно -1 , что означает, что должны быть выполнены все возможные разделения — так же, как если бы было полностью опущено: >>> >>> 'www.realpython.com'.rsplit(sep='.', maxsplit=-1) ['www', 'realpython', 'com'] >>> 'www.realpython.com'.rsplit(sep='.') ['www', 'realpython', 'com'] s.split(sep=Нет, maxsplit=-1) Разбивает строку на список подстрок. s.split() ведет себя точно так же, как s.rsplit() , за исключением того, что если указано , деления считаются с левого конца s , а не с правого конца: >>> >>> 'www. realpython.com'.split('.', maxsplit=1) ['www', 'realpython.com'] >>> 'www.realpython.com'.rsplit('.', maxsplit=1) ['www.realpython', 'com'] Если не указано, .split() и .rsplit() неразличимы. s.splitlines([]) Разрывает строку на границах строк. s.splitlines() разбивает s на строки и возвращает их в виде списка. Любой из следующих символов или последовательностей символов считается границей строки: Escape-последовательность Символ \н Новая строка \r Возврат каретки \r\n Возврат каретки + перевод строки \v или \x0b Строковая таблица \f или \x0c Подача страницы \x1c Разделитель файлов \x1d Разделитель групп \x1e Разделитель записей \x85 Следующая строка (код управления C1) \u2028 Разделитель строк Unicode \u2029 Разделитель абзацев Юникода Вот пример использования нескольких разных разделителей строк: >>> >>> 'foo\nbar\r\nbaz\fqux\u2028quux'. splitlines() ['фу', 'бар', 'баз', 'кукс', 'кукс'] Если в строке присутствуют последовательные символы границы строки, предполагается, что они разграничивают пустые строки, которые появятся в списке результатов: >>> >>> 'foo\f\f\fbar'.splitlines() ['фу', '', '', 'бар'] Если необязательный <сохраняется> 9Аргумент 0013 указан и является истинным, то в результирующих строках сохраняются границы строк: >>> >>> 'foo\nbar\nbaz\nqux'.splitlines(True) ['foo\n', 'bar\n', 'baz\n', 'qux'] >>> 'foo\nbar\nbaz\nqux'.splitlines(1) ['foo\n', 'bar\n', 'baz\n', 'qux'] Удалить рекламу байт Объекты Объект байт является одним из основных встроенных типов для работы с двоичными данными. А байт Объект представляет собой неизменяемую последовательность однобайтовых значений. Каждый элемент в объекте размером байт представляет собой небольшое целое число в диапазоне от 0 до 255 . Определение литерала байт Объект Литерал размером байт определяется так же, как строковый литерал, с добавлением префикса 'b' : >>> >>> b = b'foo bar baz' >>> б b'foo bar baz' >>> тип(б) <класс байтов> Как и в случае со строками, вы можете использовать одинарные, двойные или тройные кавычки: >>> >>> b'Содержит встроенные двойные кавычки' b'Содержит встроенные двойные кавычки' >>> b"Содержит встроенные одинарные кавычки" b"Содержит встроенные одинарные кавычки" >>> b'''Содержит встроенные двойные и одинарные кавычки''' b'Содержит встроенные "двойные" и "одинарные" кавычки. >>> b"""Содержит встроенные "двойные" и "одинарные" кавычки""" b'Содержит встроенные "двойные" и "одинарные" кавычки. В литерале размером байт разрешены только символы ASCII. Любое символьное значение, превышающее 127 , должно быть указано с использованием соответствующей управляющей последовательности: . >>> >>> b = b'foo\xddbar' >>> б b'foo\xddbar' >>> б[3] 221 >>> целое(0xdd) 221 Префикс 'r' может использоваться для литерала размером байт , чтобы отключить обработку управляющих последовательностей, как и в случае со строками: >>> >>> b = rb'foo\xddbar' >>> б b'foo\\xddbar' >>> б[3] 92 >>> хр(92) '\\' Определение объекта размером байт со встроенной функцией байт() Функция bytes() также создает объект размером байт . Какой тип объекта размером байт будет возвращен, зависит от аргумента(ов), переданного функции. Возможные формы показаны ниже. байт (, <кодировка>) Создает объект размером байт из строки. bytes(, ) преобразует строку в объект размером байт , используя str.encode() в соответствии с указанным : >>> >>> b = байты ('foo.bar', 'utf8') >>> б b'foo.bar' >>> тип(б) <класс байтов> Техническое примечание: В этой форме функции bytes() требуется аргумент . «Кодирование» относится к способу преобразования символов в целочисленные значения. Значение "utf8" указывает на формат преобразования Unicode UTF-8 , который представляет собой кодировку, которая может обрабатывать все возможные символы Unicode. UTF-8 также можно указать, указав "UTF8" , "utf-8" или "UTF-8" для <кодировка> . Дополнительные сведения см. в документации по Unicode. Пока вы имеете дело с обычными латинскими символами, UTF-8 вам подойдет. байт(<размер>) Создает объект размером байт , состоящий из нулевых ( 0x00 ) байтов. bytes() определяет объект размером байт указанного , который должен быть положительным целым числом. В результате байт объект инициализируется нулем ( 0x00 ) байт: >>> >>> b = байты (8) >>> б б'\х00\х00\х00\х00\х00\х00\х00\х00' >>> тип(б) <класс байтов> байт (<итерируемый>) Создает объект размером байт из итерируемого объекта. байт () определяет объект размером байт из последовательности целых чисел, сгенерированных <повторяемый> . должен быть итерируемым, который генерирует последовательность целых чисел n в диапазоне 0 ≤ n ≤ 255 : >>> >>> b = байты ([100, 102, 104, 106, 108]) >>> б b'dfhjl' >>> тип(б) <класс байтов> >>> б[2] 104 Удалить рекламу Операции над байтами Объекты Подобно строкам, байт объектов поддерживают общие операции с последовательностями: в операторах и не в : >>> >>> b = b'abcde' >>> b'cd' в b Истинный >>> b'foo' не в b Истинный Операторы конкатенации ( + ) и репликации ( * ): >>> >>> b = b'abcde' >>> б + б'фги' b'abcdefghi' >>> б * 3 b'abcdeabcdeabcde' Индексация и нарезка: >>> >>> b = b'abcde' >>> б[2] 99 >>> б[1:3] b'bc' Встроенные функции: >>> >>> длина(б) 5 >>> мин(б) 97 >>> макс(б) 101 Многие из методов, определенных для строковых объектов, действительны также для байт объектов: >>> >>> b = b'foo,bar,foo,baz,foo,qux' >>> b. count(b'foo') 3 >>> b.endswith(b'qux') Истинный >>> б.найти(б'баз') 12 >>> b.split(sep=b',') [б'фу', б'бар', б'фу', б'баз', б'фу', б'кукс'] >>> б.центр(30, б'-') б'---фу,бар,фу,баз,фу,кукс----' Однако обратите внимание, что когда эти операторы и методы вызываются для объекта размером байт , операнд и аргументы также должны быть объектами размером байт : >>> >>> b = b'foo.bar' >>> б + '.баз' Traceback (последний последний вызов): Файл "", строка 1, в б + '.баз' TypeError: невозможно объединить байты в строку >>> б + б'.баз' б'фу.бар.баз' >>> b.split(sep='.') Traceback (последний последний вызов): Файл "", строка 1, в b.split(sep='.') TypeError: требуется байтовый объект, а не 'str' >>> b.split(sep=b'.') [б'фу', б'бар'] Хотя определение и представление объекта размером байт основано на тексте ASCII, на самом деле оно ведет себя как неизменяемая последовательность небольших целых чисел в диапазоне от 0 до 255 включительно. Вот почему один элемент из объекта байт отображается как целое число: >>> >>> b = b'foo\xddbar' >>> б[3] 221 >>> шестнадцатеричный (b[3]) '0xdd' >>> мин(б) 97 >>> макс(б) 221 Срез отображается как объект размером байт , даже если его длина составляет всего один байт: >>> >>> б[2:3] до н.э' Вы можете преобразовать объект размером байт в список целых чисел с помощью встроенной функции list() : >>> >>> список(б) [97, 98, 99, 100, 101] Шестнадцатеричные числа часто используются для указания двоичных данных, поскольку две шестнадцатеричные цифры непосредственно соответствуют одному байту. 9Класс 0012 bytes поддерживает два дополнительных метода, облегчающих преобразование в строку шестнадцатеричных цифр и обратно. bytes. fromhex() Возвращает объект размером байт , созданный из строки шестнадцатеричных значений. bytes.fromhex() возвращает объект bytes , полученный в результате преобразования каждой пары шестнадцатеричных цифр в в соответствующее значение байта. Шестнадцатеричные пары цифр в может быть дополнительно разделен пробелом, который игнорируется: >>> >>> b = bytes.fromhex('aa 68 4682cc ') >>> б б'\xaahF\x82\xcc' >>> список(б) [170, 104, 70, 130, 204] Примечание: Этот метод является методом класса, а не методом объекта. Он привязан к классу байт , а не к объекту байт . В следующих руководствах по объектно-ориентированному программированию вы узнаете гораздо больше о различиях между классами, объектами и их соответствующими методами. Пока просто обратите внимание, что этот метод вызывается на байт класс, не на объекте b . b.hex() Возвращает строку шестнадцатеричного значения из объекта размером байт . b.hex() возвращает результат преобразования байт объекта b в строку пар шестнадцатеричных цифр. То есть он делает обратное .fromhex() : >>> >>> b = bytes.fromhex('aa 68 4682cc ') >>> б б'\xaahF\x82\xcc' >>> b.hex() 'аа684682cc' >>> введите (b.hex()) <класс 'ул'> Примечание: В отличие от .fromhex() , .hex() является методом объекта, а не методом класса. Таким образом, он вызывается для объекта класса байт , а не для самого класса. Удалить рекламу bytearray Объекты Python поддерживает другой тип двоичной последовательности, который называется bytearray . bytearray объектов очень похожи на bytes объектов, несмотря на некоторые отличия: В Python нет специального встроенного синтаксиса для определения литерала bytearray , такого как префикс 'b' , который можно использовать для определения объекта байт . Объект bytearray всегда создается с помощью встроенной функции bytearray() : >>> >>> ba = bytearray('foo.bar.baz', 'UTF-8') >>> ба bytearray(b'foo.bar.baz') >>> bytearray(6) bytearray(b'\x00\x00\x00\x00\x00\x00') >>> bytearray([100, 102, 104, 106, 108]) байтовый массив (b'dfhjl') bytearray объекты изменяемы. Вы можете изменить содержимое объекта bytearray , используя индексирование и нарезку: >>> >>> ba = bytearray('foo.bar.baz', 'UTF-8') >>> ба bytearray(b'foo.bar. baz') >>> ба[5] = 0xee >>> ба bytearray(b'foo.b\xeer.baz') >>> ba[8:11] = b'qux' >>> ба bytearray(b'foo.b\xeer.qux') Объект bytearray может быть создан непосредственно из байт объект также: >>> >>> ba = bytearray(b'foo') >>> ба байтовый массив (b'foo') Заключение В этом учебном пособии подробно рассматривается множество различных механизмов, которые Python предоставляет для обработки строк , включая строковые операторы, встроенные функции, индексирование, нарезку и встроенные методы. Вы также познакомились с типами bytes и bytearray . Это первые рассмотренные вами составные типы, построенные из набора более мелких частей. Python предоставляет несколько составных встроенных типов. В следующем уроке вы познакомитесь с двумя наиболее часто используемыми: перечисляет и кортежа . Примите участие в викторине: Проверьте свои знания с помощью нашей интерактивной викторины «Строки Python и символьные данные». По завершении вы получите балл, чтобы вы могли отслеживать свой прогресс в обучении с течением времени: Пройдите тест » Смотреть сейчас Это руководство содержит связанный с ним видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Strings and Character Data in Python 9.0065 Строки Python (с примерами) В этом руководстве вы научитесь создавать, форматировать, изменять и удалять строки в Python. Кроме того, вы познакомитесь с различными строковыми операциями и функциями. Что такое строка в Python? Строка — это последовательность символов. Персонаж — это просто символ. Например, в английском языке 26 символов. Компьютеры работают не с символами, а с числами (двоичными). Несмотря на то, что вы можете видеть символы на экране, внутри они хранятся и обрабатываются как комбинация нулей и единиц. Это преобразование символа в число называется кодированием, а обратный процесс — декодированием. ASCII и Unicode — одни из самых популярных используемых кодировок. В Python строка представляет собой последовательность символов Unicode. Юникод был введен, чтобы включить каждый символ на всех языках и обеспечить единообразие кодирования. Вы можете узнать о Unicode из Python Unicode. Как создать строку в Python? Строки можно создавать, заключая символы в одинарные или двойные кавычки. В Python можно использовать даже тройные кавычки, но обычно они используются для представления многострочных строк и строк документации. # определение строк в Python # все нижеперечисленное эквивалентно my_string = 'Привет' печать (моя_строка) my_string = "Привет" печать (моя_строка) my_string = '''Привет''' печать (моя_строка) # строка с тройными кавычками может расширять несколько строк my_string = """Здравствуйте, добро пожаловать в мир Python""" print(my_string) Когда вы запустите программу, вывод будет: Привет Привет Привет Здравствуйте, добро пожаловать в мир Python Как получить доступ к символам в строке? Мы можем получить доступ к отдельным символам, используя индексацию, и к диапазону символов, используя нарезку. Индекс начинается с 0. Попытка доступа к символу вне диапазона индекса вызовет ошибку IndexError . Индекс должен быть целым числом. Мы не можем использовать числа с плавающей запятой или другие типы, это приведет к TypeError . Python допускает отрицательное индексирование своих последовательностей. Индекс -1 относится к последнему элементу, -2 к предпоследнему элементу и так далее. Мы можем получить доступ к ряду элементов в строке, используя оператор среза : (двоеточие). #Доступ к строковым символам в Python ул = 'программиз' печать('стр = ', ул) #первый символ печать ('стр [0] = ', стр [0]) #последний символ печать ('стр [-1] = ', стр [-1]) # нарезка со 2-го по 5-й символ печать ('стр [1: 5] = ', стр [1: 5]) # нарезка с 6-го по 2-й последний символ print('str[5:-2] = ', str[5:-2]) Когда мы запускаем вышеуказанную программу, мы получаем следующий вывод: стр = программа ул[0] = р ул[-1] = г ул[1:5] = рогр ул[5:-2] = утра Если мы попытаемся получить доступ к индексу вне диапазона или использовать числа, отличные от целых, мы получим ошибки. # индекс должен быть в диапазоне >>> моя_строка[15] ... IndexError: индекс строки вне допустимого диапазона # индекс должен быть целым числом >>> моя_строка[1.5] ... TypeError: строковые индексы должны быть целыми числами Нарезку лучше всего визуализировать, рассматривая индекс как находящийся между элементами, как показано ниже. Если мы хотим получить доступ к диапазону, нам нужен индекс, который будет нарезать часть строки. Нарезка строк в Python Как изменить или удалить строку? Строки неизменяемы. Это означает, что элементы строки не могут быть изменены после того, как они были назначены. Мы можем просто переназначить разные строки одному и тому же имени. >>> my_string = 'programiz' >>> my_string[5] = 'а' ... TypeError: объект 'str' не поддерживает назначение элементов >>> my_string = 'Питон' >>> моя_строка 'Python' Мы не можем удалять или удалять символы из строки. Но полное удаление строки возможно с помощью del ключевое слово. >>> удалить my_string[1] ... TypeError: объект 'str' не поддерживает удаление элемента >>> удалить my_string >>> моя_строка ... NameError: имя 'my_string' не определено Операции со строками в Python Существует множество операций, которые можно выполнять со строками, что делает их одним из наиболее часто используемых типов данных в Python. Чтобы узнать больше о типах данных, доступных в Python, посетите: Типы данных Python Конкатенация двух или более строк Объединение двух или более строк в одну называется конкатенацией. Оператор + делает это в Python. Простое написание двух строковых литералов вместе также объединяет их. Оператор * может использоваться для повторения строки заданное количество раз. # Строковые операции Python str1 = 'Привет' str2 = 'Мир!' # используя + print('str1 + str2 = ', str1 + str2) # с использованием * print('str1 * 3 =', str1 * 3) Когда мы запускаем вышеуказанную программу, мы получаем следующий вывод: str1 + str2 = HelloWorld! str1 * 3 = HelloHelloHello Запись двух строковых литералов вместе также объединяет их, как оператор + . Если мы хотим объединить строки в разных строках, мы можем использовать круглые скобки. >>> # два строковых литерала вместе >>> 'Привет, мир!' 'Привет, мир!' >>> # с использованием круглых скобок >>> s = ('Привет' ... 'Мир') >>> с «Привет, мир» Итерация по строке Мы можем выполнить итерацию по строке, используя цикл for. Вот пример подсчета количества «l» в строке. # Перебор строки количество = 0 для письма в «Hello World»: если (буква == 'л'): количество += 1 print(count,' найдено писем') Когда мы запустим вышеуказанную программу, мы получим следующий вывод: Найдено 3 буквы Тест на принадлежность к строке Мы можем проверить, существует ли подстрока в строке или нет, используя ключевое слово в . >>> 'а' в 'программе' Истинный >>> 'в' не в 'бою' False Встроенные функции для работы с Python Различные встроенные функции, работающие с последовательностями, также работают со строками. Некоторые из наиболее часто используемых: enumerate() и len() . Функция enumerate() возвращает объект перечисления. Он содержит индекс и значение всех элементов в строке в виде пар. Это может быть полезно для итерации. Аналогично, len() возвращает длину (количество символов) строки. ул = «холодный» # перечислить() list_enumerate = список (перечислить (строка)) print('список(перечислить(str) = ', list_enumerate) # количество символов print('len(str) = ', len(str)) Когда мы запускаем вышеуказанную программу, мы получаем следующий вывод: list(enumerate(str) = [(0, 'c'), (1, 'o'), (2, 'l'), (3, 'd')] len(str) = 4 Форматирование строки Python Escape Sequence Если мы хотим напечатать текст вроде Он сказал: "Что там?" , мы не можем использовать ни одинарные, ни двойные кавычки. Это приведет к SyntaxError , поскольку сам текст содержит как одинарные, так и двойные кавычки. >>> print("Он сказал: "Что там?"") ... SyntaxError: неверный синтаксис >>> print('Он сказал: "Что там?"') ... SyntaxError: недопустимый синтаксис Один из способов обойти эту проблему — использовать тройные кавычки. В качестве альтернативы мы можем использовать escape-последовательности. Управляющая последовательность начинается с обратной косой черты и интерпретируется по-разному. Если мы используем одинарную кавычку для представления строки, все одинарные кавычки внутри строки должны быть экранированы. То же самое и с двойными кавычками. Вот как это можно сделать для представления приведенного выше текста. # используя тройные кавычки print('''Он сказал: "Что там?"''') # экранирование одинарных кавычек print('Он сказал: "Что там?"') # экранирование двойных кавычек print("Он сказал \"Что там?\"") Когда мы запустим вышеуказанную программу, мы получим следующий результат: Он сказал: "Что там?" Он сказал: "Что там?" Он сказал: "Что там?" Вот список всех escape-последовательностей, поддерживаемых Python. Escape-последовательность Описание \новая строка Обратная косая черта и новая строка игнорируются \ Обратная косая черта \' Одинарная кавычка \" Двойная кавычка \а Звонок ASCII \б ASCII Backspace \ф ASCII Подача страниц \н Перевод строки ASCII \r Возврат каретки ASCII \т Горизонтальная вкладка ASCII \v Вертикальная вкладка ASCII \ооо Символ с восьмеричным значением ooo \хЧЧ Символ с шестнадцатеричным значением HH Вот несколько примеров >>> print("C:\\Python32\\Lib") C:\Python32\Библиотека >>> print("Это напечатано\nдвумя строками") Это напечатано в две строки >>> print("Это представление \x48\x45\x58") Это HEX-представление Необработанная строка для игнорирования управляющей последовательности Иногда может потребоваться игнорировать управляющую последовательность внутри строки. Для этого мы можем поместить r или R перед строкой. Это будет означать, что это необработанная строка, и любая escape-последовательность внутри нее будет проигнорирована. >>> print("Это \x61\nхороший пример") Это хороший пример >>> print(r"Это \x61\nхороший пример") Это \x61 \nхороший пример Метод format() для форматирования строк Метод format() , доступный для строкового объекта, очень универсален и эффективен при форматировании строк. Строки формата содержат фигурные скобки {} в качестве заполнителей или замещающих полей, которые заменяются. Мы можем использовать позиционные аргументы или аргументы ключевого слова, чтобы указать порядок.
# Метод форматирования строки Python() # по умолчанию (неявный) порядок default_order = "{}, {} и {}".format('Джон','Билл','Шон') print('\n--- Порядок по умолчанию ---') печать (default_order) # порядок с использованием позиционного аргумента positional_order = "{1}, {0} и {2}". format('Джон','Билл','Шон') print('\n--- Позиционный порядок ---') печать (позиционный_порядок) # порядок с использованием аргумента ключевого слова keyword_order = "{s}, {b} и {j}".format(j='Джон',b='Билл',s='Шон') print('\n--- Порядок ключевых слов ---') печать (keyword_order) 9 строка в заданном пространстве.

Мы также можем форматировать целые числа как двоичные, шестнадцатеричные и т. д., а числа с плавающей запятой можно округлять или отображать в формате экспоненты. Есть множество форматов, которые вы можете использовать. Посетите здесь, чтобы узнать обо всех форматах строк, доступных с помощью метода format() .

>>> # форматирование целых чисел >>> "Двоичное представление {0} равно {0:b}".format(12) «Двоичное представление 12 равно 1100» >>> # форматирование поплавков >>> "Представление экспоненты: {0:e}".format(1566.345) 'Представление степени: 1.566345e+03' >>> # округлить >>> "Одна треть: {0:.3f}".format(1/3) «Одна треть: 0,333» >>> # выравнивание строк >>> "|{:<10}|{:^10}|{:>10}|". format('масло','хлеб','ветчина') '|масло | хлеб | ветчина |
Форматирование в старом стиле
Мы даже можем форматировать строки подобно старому sprintf() стилю, используемому в языке программирования C. Для этого мы используем оператор % .
>>> х = 12,3456789 >>> print('Значение x равно %3.2f' %x) Значение x равно 12,35. >>> print('Значение x равно %3.4f' %x) Значение x равно 12,3457
Общие строковые методы Python
Существует множество методов, доступных со строковым объектом. 9Метод 0012 format() , о котором мы упоминали выше, является одним из них. Некоторые из часто используемых методов: lower() , upper() , join() , split() , find() , replace() и т. д. Вот полный список все встроенные методы для работы со строками в Python.
>>> "ПрогРаМиЗ".нижний() 'программировать' >>> "ПрогРаМиЗ".upper() ПРОГРАММИРОВАНИЕ >>> "Это разделит все слова на список". split() ['Это', 'будет', 'разделить', 'все', 'слова', 'в', 'а', 'список'] >>> ' '.join(['Это', 'будет', 'присоединиться', 'все', 'слова', 'в', 'а', 'строка']) «Это объединит все слова в строку» >>> 'С Новым годом'.find('ew') 7 >>> 'С Новым годом'.replace('Счастливый','Блестящий') «Блестящий Новый год»
Набор Python (с примерами)
В этом руководстве вы узнаете все о наборах Python; как они создаются, добавляются или удаляются из них элементы, и все операции, выполняемые над множествами в Python.
Набор — это неупорядоченный набор элементов. Каждый элемент набора уникален (без дубликатов) и должен быть неизменным (не может быть изменен).
Однако сам набор может быть изменен. Мы можем добавлять или удалять элементы из него.
Множества также можно использовать для выполнения математических операций над множествами, таких как объединение, пересечение, симметричная разность и т. д.
Создание наборов Python
Набор создается путем помещения всех элементов (элементов) в фигурные скобки {} , разделенных запятой, или с помощью встроенной функции set() .
Может иметь любое количество элементов, и они могут быть разных типов (целые числа, числа с плавающей запятой, кортежи, строки и т. д.). Но множество не может иметь в качестве своих элементов изменяемые элементы, такие как списки, наборы или словари.
# Различные типы наборов в Python # набор целых чисел мой_набор = {1, 2, 3} печать (мой_набор) # набор смешанных типов данных my_set = {1.0, "Привет", (1, 2, 3)} печать (мой_набор)
Выход
{1, 2, 3} {1.0, (1, 2, 3), "Привет"}
Попробуйте также следующие примеры.
# набор не может иметь дубликатов # Вывод: {1, 2, 3, 4} my_set = {1, 2, 3, 4, 3, 2} печать (мой_набор) # мы можем сделать множество из списка # Вывод: {1, 2, 3} my_set = установить ([1, 2, 3, 2]) печать (мой_набор) # в наборе не может быть изменяемых элементов # здесь [3, 4] — изменяемый список # это вызовет ошибку. my_set = {1, 2, [3, 4]}
Вывод
{1, 2, 3, 4} {1, 2, 3} Traceback (последний последний вызов): Файл "", строка 15, в my_set = {1, 2, [3, 4]} TypeError: unhashable type: 'list'
Создать пустой набор немного сложно.
Пустые фигурные скобки {} создаст пустой словарь в Python. Чтобы создать набор без каких-либо элементов, мы используем функцию set() без каких-либо аргументов.
# Различать набор и словарь при создании пустого набора # инициализируем {} а = {} # проверить тип данных a печать (тип (а)) # инициализируем с помощью set() а = установить () # проверить тип данных a печать (тип (а))
Выход
<класс 'словарь'>
Изменение набора в Python
Наборы изменяемы. Однако, поскольку они неупорядочены, индексация не имеет смысла.
Мы не можем получить доступ к элементу набора или изменить его с помощью индексации или нарезки. Установить тип данных не поддерживает его.
Мы можем добавить один элемент, используя метод add() , и несколько элементов, используя метод update() . 9Метод 0012 update() может принимать в качестве аргумента кортежи, списки, строки или другие множества. Во всех случаях дубликаты избегаются.
# инициализировать my_set мой_набор = {1, 3} печать (мой_набор) # мой_набор[0] # если вы раскомментируете строку выше # вы получите сообщение об ошибке # TypeError: объект 'set' не поддерживает индексацию # добавляем элемент # Вывод: {1, 2, 3} my_set.add(2) печать (мой_набор) # добавить несколько элементов # Вывод: {1, 2, 3, 4} my_set.update([2, 3, 4]) печать (мой_набор) # добавить список и установить # Вывод: {1, 2, 3, 4, 5, 6, 8} my_set.update([4, 5], {1, 6, 8}) печать (мой_набор)
Выход
{1, 3} {1, 2, 3} {1, 2, 3, 4} {1, 2, 3, 4, 5, 6, 8}
Удаление элементов из набора
Конкретный элемент можно удалить из набора с помощью методов discard() и remove() .
Единственная разница между ними состоит в том, что функция discard() оставляет набор без изменений, если элемент отсутствует в наборе. С другой стороны, функция remove() вызовет ошибку в таком состоянии (если элемент отсутствует в наборе).
Следующий пример проиллюстрирует это.
# Разница между discard() и remove() # инициализировать my_set my_set = {1, 3, 4, 5, 6} печать (мой_набор) # отбросить элемент # Вывод: {1, 3, 5, 6} my_set.discard(4) печать (мой_набор) # удалить элемент # Вывод: {1, 3, 5} my_set.remove(6) печать (мой_набор) # отбросить элемент # отсутствует в my_set # Вывод: {1, 3, 5} my_set.discard(2) печать (мой_набор) # удалить элемент # отсутствует в my_set # вы получите сообщение об ошибке. # Вывод: KeyError my_set.remove(2)
Выход
{1, 3, 4, 5, 6} {1, 3, 5, 6} {1, 3, 5} {1, 3, 5} Traceback (последний последний вызов): Файл "", строка 28, в KeyError: 2
Точно так же мы можем удалить и вернуть элемент, используя метод pop() .
Поскольку набор является неупорядоченным типом данных, невозможно определить, какой элемент будет извлечен. Это совершенно произвольно.
Мы также можем удалить все предметы из набора, используя метод очистки() .
# инициализировать my_set # Вывод: набор уникальных элементов my_set = установить ("HelloWorld") печать (мой_набор) # извлекаем элемент # Вывод: случайный элемент печать (my_set.pop()) # извлечь другой элемент my_set.pop() печать (мой_набор) # очистить my_set # Вывод: установить() my_set.clear() print(my_set)
Вывод
{'H', 'l', 'r', 'W', 'o', 'd', 'e'} ЧАС {'г', 'В', 'о', 'д', 'е'} set()
Python Операции над множествами
Наборы можно использовать для выполнения математических операций над множествами, таких как объединение, пересечение, разность и симметричная разность. Мы можем сделать это с помощью операторов или методов.
Рассмотрим следующие два набора для следующих операций.
>>> А = {1, 2, 3, 4, 5} >>> B = {4, 5, 6, 7, 8}
Set Union
Set Union в Python
Union of A и B представляет собой набор всех элементов из обоих наборов.
Объединение выполняется с помощью | оператор. То же самое можно сделать с помощью метода union() .
# Установить метод объединения # инициализируем А и Б А = {1, 2, 3, 4, 5} В = {4, 5, 6, 7, 8} # использовать | оператор # Вывод: {1, 2, 3, 4, 5, 6, 7, 8} напечатать (А | В)
Выход
{1, 2, 3, 4, 5, 6, 7, 8}
Попробуйте выполнить следующие примеры в оболочке Python.
# использовать функцию объединения >>> А.союз(Б) {1, 2, 3, 4, 5, 6, 7, 8} # используем функцию объединения на B >>> Б.союз(А) {1, 2, 3, 4, 5, 6, 7, 8}
Пересечение множества
Пересечение множества в Python
Пересечение A и B — это набор элементов, общих для обоих наборов.
Пересечение выполняется с помощью 9Оператор 0012 и . То же самое можно сделать с помощью метода пересечения() .
# Пересечение множеств # инициализируем А и Б А = {1, 2, 3, 4, 5} В = {4, 5, 6, 7, 8} # использование и оператор # Вывод: {4, 5} печать(A и B)
Вывод
{4, 5}
Попробуйте выполнить следующие примеры в оболочке Python.
# использовать функцию пересечения на A >>> А.пересечение(Б) {4, 5} # используем функцию пересечения на B >>> Б.пересечение(А) {4, 5}
Set Difference
Set Difference в Python
Отличие набора B от набора A ( A - B ) представляет собой набор элементов, которые есть только в
5 3 B 3 в , но не . Точно так же B - A является набором элементов в B , но не в A .
Различие выполняется с помощью оператора - . То же самое можно сделать, используя метод Differenti() .
# Разница двух наборов # инициализируем А и Б А = {1, 2, 3, 4, 5} В = {4, 5, 6, 7, 8} # use - оператор на A # Вывод: {1, 2, 3} печать(A - B)
Вывод
{1, 2, 3}
Попробуйте выполнить следующие примеры в оболочке Python.
# использовать функцию разницы на A >>> А. разница(Б) {1, 2, 3} # use - оператор на B >>> Б - А {8, 6, 7} # используем функцию разности на B >>> Б.разница(А) {8, 6, 7}
9Б)
Выход
{1, 2, 3, 6, 7, 8}
Попробуйте выполнить следующие примеры в оболочке Python.
# использовать функцию symmetric_difference для A >>> А.симметричная_разница(Б) {1, 2, 3, 6, 7, 8} # использовать функцию symmetric_difference на B >>> Б. симметричная_разница (А) {1, 2, 3, 6, 7, 8}
Другие методы установки Python
Существует много методов установки, некоторые из которых мы уже использовали выше. Вот список всех методов, которые доступны с установленными объектами:
.
Метод Описание
добавить() Добавляет элемент в набор
очистить() Удаляет все элементы из набора
копирование() Возвращает копию набора
разница() Возвращает разницу двух или более наборов в виде нового набора
разность_обновление() Удаляет все элементы другого набора из этого набора
отбросить() Удаляет элемент из набора, если он является членом. (Ничего не делать, если элемента нет в наборе)
пересечение() Возвращает пересечение двух наборов как новый набор
cross_update() Обновляет набор пересечением себя и другого
isdisjoint() Возвращает Истинно , если два набора имеют нулевое пересечение
issubset() Возвращает True , если другой набор содержит этот набор
issuperset () Возвращает True , если этот набор содержит другой набор
поп() Удаляет и возвращает произвольный элемент множества. Вызывает KeyError , если набор пуст
удалить() Удаляет элемент из набора. Если элемент не является членом, вызывает ошибку KeyError
симметричная_разность() Возвращает симметричную разность двух наборов в виде нового набора
симметричная_разница_обновление() Обновляет набор с симметричной разностью себя и другого
объединение() Возвращает объединение наборов в новый набор
обновление() Обновляет набор объединением себя и других
Другие операции с множествами
Проверка принадлежности множества
Мы можем проверить, существует ли элемент в множестве или нет, используя ключевое слово в .
# в ключевом слове в наборе # инициализировать my_set my_set = установить ("яблоко") # проверяем, присутствует ли 'a' # Вывод: Истина print('a' в my_set) # проверить, присутствует ли 'p' # Вывод: Ложь print('p' нет в my_set)
Выход
Правда False
Перебор набора
Мы можем перебирать каждый элемент набора с помощью цикла for .
>>> для письма в наборе ("яблоко"): ... печать (письмо) ... а п е l
Встроенные функции с набором
Встроенные функции, такие как all() , any() , enumerate() , len() , max() , min ) , отсортировано() , sum() и т. д. обычно используются с наборами для выполнения различных задач.
Функция Описание
все() Возвращает True , если все элементы набора истинны (или если набор пуст).
любой() Возвращает True , если любой элемент набора истинен. Если набор пуст, возвращает False .
перечислить() Возвращает перечисляемый объект. Он содержит индекс и значение для всех элементов набора в виде пары.
лен() Возвращает длину (количество элементов) в наборе.
макс() Возвращает самый большой элемент в наборе.
мин() Возвращает наименьший элемент в наборе.
отсортировано() Возвращает новый отсортированный список из элементов набора (сам набор не сортируется).
сумма() Возвращает сумму всех элементов набора.
Python Frozenset
Frozenset — это новый класс, обладающий характеристиками набора, но его элементы нельзя изменить после назначения. В то время как кортежи — это неизменяемые списки, замороженные наборы — неизменные наборы.
Изменяемые наборы нельзя хешировать, поэтому их нельзя использовать в качестве ключей словаря. С другой стороны, наборы заморозки можно хешировать и использовать в качестве ключей к словарю.
Наборы Frozenset можно создавать с помощью функции Frozenset().
Этот тип данных поддерживает такие методы, как: объединение() . Будучи неизменным, он не имеет методов, которые добавляют или удаляют элементы.
# Фрозенсеты # инициализируем А и Б A = замороженный набор ([1, 2, 3, 4]) B = замороженный набор ([3, 4, 5, 6])
Попробуйте эти примеры в оболочке Python.
>>> A.isdisjoint(B) ЛОЖЬ >>> А.разница(Б) замороженный набор ({1, 2}) >>> А | Б замороженный набор ({1, 2, 3, 4, 5, 6}) >>> А.добавить(3) ... AttributeError: у объекта 'frozenset' нет атрибута 'add'
Работа со строками в Python 3
В Python последовательности символов называются строками . Он используется в Python для записи текстовой информации, такой как имена. Строки Python являются «неизменяемыми», что означает, что их нельзя изменить после создания.
Создание строки
Строки можно создавать с использованием одинарных, двойных или даже тройных кавычек. Python обрабатывает одинарные кавычки так же, как двойные кавычки.
Python3
String = 'Hello Geek'
print ( "Creating string with single quotes :" , String)

Строка = "yes, I am Geek"
print ( "Creating String with double quotes :" , String)

String =
print ( "Создание строки с тройными кавычками:" , строка)
Вывод
Создание строки с одинарными кавычками: Hello Geek Создание строки с двойными кавычками: да, я гик Создание строки с тройными кавычками: да, я гик 9SyntaxError: неверный синтаксис
Причиной указанной выше ошибки является одинарная кавычка в Да, я остановил строку. Если вы хотите напечатать ‘WithQuotes’ в python, это нельзя сделать только с помощью одинарных (или двойных) кавычек, это требует одновременного использования обоих. Лучший способ избежать этой ошибки — использовать двойные кавычки.
Пример:
Python3
print ( "'WithQuotes'" )
Печать ( "Hello 'Python'" )

( » . ( 'Привет "Питон"' )
Вывод
'WithQuotes' Привет "Питон" "С цитатами" Привет "Питон"
Примечание: Для получения дополнительной информации см. Одинарные и двойные кавычки | Python
Индексирование строк
Строки представляют собой последовательность символов, что означает, что Python может использовать индексы для вызова частей последовательности. Есть два способа индексации.
Positive Indexing
Negative Indexing
Positive indexing
Python3
String = "GEEK"

print ( "The 1st element is : " , String[ 0 ])

print ( "The 2nd element IS: « , строка [ 1 ])

Печать ( » Элемент 3 -й 3 -й. 0003
print ( "The 4th element is : " , String[ 3 ])
Output
The 1st element is : G 2-й элемент: E 3-й элемент: E 4-й элемент: K
Отрицательная индексация
Python3
Строка = "GEEK" 33330020
print ( "The 4th element is : " , String[ - 1 ])

print ( "The 3 -й элемент: « , строка [ - 2 ])

Печать ( ». Элемент 2ND -: " ( ". Элемент 2ND -: " ( " Элемент 2ND -: " ( ".0013 3 ])
print ( "The 1th element is : " , String[ - 4 ])
Output
4-й элемент: K 3-й элемент: E 2-й элемент: E 1-й элемент: G
Обновление строк
В Python не допускается обновление или удаление символов из строки. Это вызовет ошибку, поскольку назначение или удаление элемента из строки не поддерживается. Python может позволить вам переназначить новую строку существующей строке.
Python3
String = "Geeks"

String[ 0 ] = "Hi!, Geeks"
Вывод
Трассировка (последний последний вызов):
Файл «/home/b298782a4e04df4950426bf4bd5bee99. py», строка 5, in
Strings Объект 'str' не поддерживает назначение элемента
Обновление всей строки
Python3
Строка = "Hello Geeks"
Печать
( 9003
.
Строка = "Geeksforgeeks"
Печать ( "После обновления:" , String) 9003
012
Строка = 'Привет, мир!'
print ( "Updated String :- " , String[: 6 ] + 'Python' )
Output
Перед обновлением: Привет, компьютерщики После обновления: Geeksforgeeks Обновленная строка: - Привет, Python
Нарезка струн
Нарезка Python заключается в получении подстроки из заданной строки путем ее нарезки соответственно от начала до конца.
Нарезку Python можно выполнить двумя способами.
slice() Constructor
Extending Indexing
Python3
String = "Geekforgeeks"

s1 = slice ( 3 )

print (String[s1])

print (String[: 6 ])

print (Строка [ 1 : 7 ])
4 Ge Выход Гикфо искать
Нарезка с отрицательным индексом.
Python3
String = "Geekforgeeks"

s1 = slice ( - 1 )

Печать (String [S1])

Печать (Строка [ 0 : - 9.0012 3 ])
Выход
Geekforgeek Geekforge
Мы можем использовать [ : : ] для указания частоты печати элементов. Он указывает шаг, после которого каждый элемент будет напечатан, начиная с заданного индекса. Если ничего не указано, то он начинается с 0-го индекса.
Python3
Строка = "Geekforgeeks"

print (String[:: 1 ])

print (String[ 2 :: 2 ])

Печать (String [:: - 1 ])

94
9005
9014 9014. эфрек СкигрофкиГ
Примечание: Для получения дополнительной информации см. Разделение строк в Python
Форматирование строк
str.format() и Методы f-string используются для добавления форматированных объектов в печатные строковые операторы. Метод string format() форматирует заданную строку. Он допускает множественные замены и форматирование значений.
Python3
Строка = 'Geeksforgeeks'
print ( "{}, A computer science portal for geeks."
. format (String))

String = 'Geeks'
Печать ( "Привет {}, как у вас?0013 = 2
print ( "I want {} Burgers! " . format (val))
Output
Geeksforgeeks, Портал информатики для гиков. Привет знатоки, как дела? Я хочу 2 бургера!
Примечание: Для получения дополнительной информации см. Python | функция format()
Отформатированные f-строки литералы имеют префикс «f» и фигурные скобки { }, содержащие выражения, которые будут заменены их значениями.
Python3
Строка = 'Geekforgeeks'
Print (F "{String strice tmeall Nicke.
Строка = 'Geek'
Печать (F "Да, I AM {String} ). 0013 = 3
book_in_bag = 12
print (f 'There are total {bags * book_in_bag} books' )

Dic = { 'Portal' : 'Geeksforgeeks' , 'for' : 'Geeks' }
print (f "{Dic['Portal']} — портал компьютерных наук для {Dic['for']}" )
Вывод 4 портал для гиков Да, я гик Всего 36 книг Geeksforgeeks — портал информатики для гиков.
Примечание: Для получения дополнительной информации см. f-строки в Python 3 — Форматированные строковые литералы

Строки Python | Обучение Python
Python имеет встроенный строковый класс с именем «str» со многими удобными функциями (существует более старый модуль с именем «string», который вам не следует использовать). Строковые литералы могут быть заключены в двойные или одинарные кавычки, хотя одинарные кавычки используются чаще. Экранирование обратной косой черты работает обычным образом как в литералах с одинарными, так и с двойными кавычками - например. \n \' \". Строковый литерал в двойных кавычках может содержать одинарные кавычки без какой-либо суеты (например, «Я этого не делал»), а также строка в одинарных кавычках может содержать двойные кавычки. Строковый литерал может занимать несколько строк, но есть должен быть обратный слэш \ в конце каждой строки, чтобы избежать перехода на новую строку Строковые литералы, заключенные в тройные кавычки, """ или ''', могут занимать несколько строк текста.
Строки Python являются «неизменяемыми», что означает, что они не могут быть изменены после создания (строки Java также используют этот неизменяемый стиль). Поскольку строки не могут быть изменены, мы создаем *новые* строки по мере продвижения для представления вычисляемых значений. Так, например, выражение («привет» + «там») принимает две строки «привет» и «там» и создает новую строку «привет там».
Доступ к символам в строке можно получить с помощью стандартного синтаксиса [ ], и, как в Java и C++, Python использует индексацию с отсчетом от нуля, поэтому, если s равно 'hello', s[1] равно 'e'. Если индекс выходит за пределы строки, Python выдает ошибку. Стиль Python (в отличие от Perl) состоит в том, чтобы останавливаться, если он не может сказать, что делать, а не просто создавать значение по умолчанию. Удобный синтаксис «среза» (ниже) также работает для извлечения любой подстроки из строки. Функция len(string) возвращает длину строки. Синтаксис [ ] и функция len() на самом деле работают с любым типом последовательности — строками, списками и т. д. Python пытается сделать так, чтобы его операции работали согласованно для разных типов. Новичок в Python: не используйте «len» в качестве имени переменной, чтобы не блокировать функцию len(). Оператор «+» может объединить две строки. Обратите внимание, что в приведенном ниже коде переменные не объявлены заранее — просто присвойте им значение и вперед.
с = 'привет' напечатать s[1] ## я печатать линзы ## 2 print s + 'там' ## привет там
В отличие от Java, '+' не преобразует автоматически числа или другие типы в строковую форму. Функция str() преобразует значения в строковую форму, чтобы их можно было комбинировать с другими строками.
пи = 3,14 ##text = 'Значение pi равно ' + pi ## НЕТ, не работает text = 'Значение числа пи равно ' + str(pi) ## yes
Для чисел стандартные операторы +, /, * работают как обычно. Оператора ++ нет, но работают +=, -= и т.д. Если вы хотите целочисленное деление, используйте 2 косые черты - например. 6 // 5 равно 1
Функция «печать» обычно выводит один или несколько элементов Python, за которыми следует новая строка. «Необработанный» строковый литерал имеет префикс «r» и пропускает все символы без специальной обработки обратной косой черты, поэтому r'x\nx' оценивается как строка длины 4 «x\nx». «print» может принимать несколько аргументов, чтобы изменить способ вывода (см. определение функции печати на python.org), например установка «end» на «», чтобы больше не печатать новую строку после завершения печати всех элементов.
raw = r'это\t\n и это' # это\t\n и это печать (сырая) multi = """Это были лучшие времена. Это были худшие времена.""" # Это были лучшие времена. # Это были худшие времена. печать (мульти)
Строковые методы
Вот некоторые из наиболее распространенных строковых методов. Метод похож на функцию, но он работает «на» объекте. Если переменная s является строкой, то код s. lower() запускает метод lower() для этого строкового объекта и возвращает результат (эта идея метода, работающего с объектом, является одной из основных идей, составляющих Object ориентированное программирование, ООП). Вот некоторые из наиболее распространенных строковых методов:
s.lower(), s.upper() -- возвращает строчную или прописную версию строки
s.strip() -- возвращает строку с удаленными пробелами в начале и в конце
s.isalpha()/s.isdigit()/s.isspace()... -- проверяет, относятся ли все строковые символы к различным классам символов
s.startswith('other'), s.endswith('other') -- проверяет, начинается ли строка или заканчивается заданной другой строкой
s.find('other') -- ищет указанную другую строку (не регулярное выражение) в пределах s и возвращает первый индекс, с которого она начинается, или -1, если не найдено
s.replace('old', 'new') -- возвращает строку, в которой все вхождения слова 'old' заменены на 'new'
s. split('delim') -- возвращает список подстрок, разделенных заданным разделителем. Разделитель не является регулярным выражением, это просто текст. 'aaa,bbb,ccc'.split(',') -> ['aaa', 'bbb', 'ccc']. В качестве удобного частного случая s.split() (без аргументов) разбивается на все пробельные символы.
s.join(list) -- в отличие от split(), объединяет элементы в заданном списке вместе, используя строку в качестве разделителя. например '---'.join(['aaa', 'bbb', 'ccc']) -> aaa---bbb---ccc
Поиск в Google «python str» должен привести вас к официальным строковым методам python.org, в которых перечислены все методы str.
Python не имеет отдельного символьного типа. Вместо этого выражение типа s[8] возвращает строку длиной 1, содержащую символ. С этой строкой-длиной-1 операторы ==,
Фрагменты строк
Синтаксис "фрагмент" представляет собой удобный способ обращения к частям последовательностей, обычно к строкам и спискам. Срез s[start:end] — это элементы, начинающиеся с начала и продолжающиеся до конца, но не включая его. Предположим, у нас есть s = "Привет"
s[1:4] равно 'ell' -- символы, начинающиеся с индекса 1 и доходящие до индекса 4, но не включая его
s[1:] is 'ello' -- опускание индекса по умолчанию для начала или конца строки
s[:] is 'Hello' -- опускание обоих всегда дает нам копию всего (это питонический способ скопировать последовательность, такую как строка или список)
s[1:100] is 'ello' -- слишком большой индекс усекается до длины строки
Стандартные индексы с отсчетом от нуля обеспечивают легкий доступ к символам в начале строки. В качестве альтернативы Python использует отрицательные числа, чтобы упростить доступ к символам в конце строки: s[-1] — это последний символ 'o', s[-2] — это 'l' предпоследний чар и так далее. Отрицательные индексы отсчитываются от конца строки:
s[-1] is 'o' -- последний символ (первый с конца)
s[-4] это 'e' -- 4-й с конца
s[:-3] - это 'He' -- идет вверх, но не включает последние 3 символа.
s[-3:] is 'llo' -- начиная с 3-го символа с конца и до конца строки.
Это четкая истина о срезах, что для любого индекса n s[:n] + s[n:] == s . Это работает даже для n отрицательных или за пределами. Или, другими словами, s[:n] и s[n:] всегда разбивают строку на две части строки, сохраняя все символы. Как мы увидим позже в разделе списка, срезы работают и со списками.
Форматирование строк
Python может делать одну изящную вещь — автоматически преобразовывать объекты в строка, подходящая для печати. Два встроенных способа сделать это — форматированная строка. литералы, также называемые "f-строками", и вызов str.format().
Форматированные строковые литералы
Форматированные строковые литералы часто используются в таких ситуациях, как:
значение = 2,7 print(f'приблизительное значение = {значение:. 2f}') # приблизительное значение = 2,79 car = {'шины':4, 'двери':2} print(f'car = {car}') # car = {'шины': 4, 'двери': 2}
Отформатированная литеральная строка имеет префикс «f» (аналогично префиксу «r», используемому для необработанных строк). Любой текст за пределами фигурных скобок '{}' распечатывается напрямую. Выражения, содержащиеся в '{}', являются распечатываются с использованием спецификации формата, описанной в спецификация формата. Есть много полезных вещей, которые вы можете сделать с форматированием, включая усечение и преобразование в экспоненциальное представление и выравнивание по левому/правому/центру.
f-строки очень полезны, когда вы хотите распечатать таблицу объектов и хотите столбцы, представляющие различные атрибуты объекта, должны быть выровнены, как
address_book = [{'name':'N.X.', 'addr':'15 Jones St', 'bonus': 70}, {'name':'JP', 'addr':'1005 5th St', 'bonus': 400}, {'имя':'АА', 'адрес':'200001 Bdwy', 'бонус': 5},] для человека в address_book: print(f'{человек["имя"]:8} || {человек["адрес"]:20} || {человек["бонус"]:>5}') # Н. Х. || 15 Джонс-Стрит || 70 # Дж. П. || 1005 5-я улица || 400 # А.А. || 200001 Шоссе || 5
String %
Python также имеет более старую функцию, подобную printf(), для составления строки. Оператор % принимает строку формата типа printf слева (%d int, %s строка, %f/%g с плавающей запятой) и совпадающие значения в кортеже справа (кортеж состоит из значений, разделенных запятые, обычно сгруппированные внутри круглых скобок):
# % оператор text = "%d поросята выйдут, или я %s, и я %s, и я взорву ваш %s." % (3, «хрип», «пыхтение», «дом»)
Приведенная выше строка довольно длинная. Предположим, вы хотите разбить ее на отдельные строки. Вы не можете просто разделить строку после «%», как в других языках, так как по умолчанию Python обрабатывает каждую строку как отдельный оператор (с положительной стороны, именно поэтому нам не нужно вводить точку с запятой в каждой строке). линия). Чтобы исправить это, заключите все выражение во внешний набор скобок — тогда выражение может занимать несколько строк. Этот метод межстрочного кода работает с различными конструкциями группировки, подробно описанными ниже: ( ), [ ], { }.
# Добавьте круглые скобки, чтобы длинная строка работала: текст = ( "%d поросята выходят, или я %s, и я %s, и я взорву ваш %s." % (3, 'пыхтение', 'пыхтение', 'дом'))
Уже лучше, но очередь все равно длинная. Python позволяет разрезать строку на куски, которые затем автоматически объединяются. Итак, чтобы сделать эту строку еще короче, мы можем сделать это:
. # Разбить строку на куски, которые Python автоматически объединяет текст = ( "Выходят %d поросята," "или я %s, и я %s," "и я взорву твой %s." % (3, 'пыхтение', 'пыхтение', 'дом'))
Строки (Юникод против байтов)
Обычные строки Python имеют юникод.
Python также поддерживает строки, состоящие из простых байтов (обозначаются префиксом «b» перед строковым литералом) как:
> byte_string = b'строка байтов' > байтовая_строка b'строка байтов'
Строка Юникода — это тип объекта, отличный от строки байтов, но различные библиотеки, такие как регулярные выражения работают правильно, если переданы строки любого типа.
Чтобы преобразовать обычную строку Python в байты, вызовите для строки метод encode(). Идя в другом направлении, метод decode() строки байтов преобразует закодированные простые байты в строку Unicode:
> usstring = 'Юникод > строка \xf1' > b = usstring.encode('utf-8') > б b'A unicode \xc6\x8e string \xc3\xb1' ## байт кодировки utf-8. Обратите внимание на префикс b. > t = b.decode('utf-8') ## Преобразование байтов обратно в строку Unicode > t == ustring ## Это то же самое, что и оригинал, ура!
Правда

В разделе чтения файлов есть пример, который показывает, как открыть текстовый файл с некоторой кодировкой и прочитать строки Unicode.
Python не использует { } для включения блоков кода для if/циклов/функций и т. д. Вместо этого Python использует двоеточие (:) и отступы/пробелы для группировки операторов. Логический тест для if не обязательно должен быть в скобках (большое отличие от C++/Java), и он может иметь предложения *elif* и *else* (мнемоника: слово "elif" имеет ту же длину, что и слово " еще").
Любое значение может быть использовано в качестве проверки условности. Все «нулевые» значения считаются ложными: None, 0, пустая строка, пустой список, пустой словарь. Также есть тип Boolean с двумя значениями: True и False (в преобразовании в int это 1 и 0). В Python есть обычные операции сравнения: ==, !=, <, <=, >, >=. В отличие от Java и C, == перегружен для корректной работы со строками. Булевы операторы — это написанные по буквам слова *и*, *или*, *не* (Python не использует стиль C && || !). Вот как может выглядеть код приложения для здоровья, предоставляющего рекомендации по питью в течение дня — обратите внимание, как каждый блок операторов then/else начинается с :, а операторы сгруппированы по отступу:

если time_hour >= 0 и time_hour
Я считаю, что пропуск ":" является моей самой распространенной синтаксической ошибкой при вводе кода выше, вероятно, потому, что это дополнительная вещь для ввода по сравнению с моими привычками C++/Java.
No related posts.

Функция	Описание
`хр()`	Преобразует целое число в символ
`порядок()`	Преобразует символ в целое число
`лен()`	Возвращает длину строки
`стр()`	Возвращает строковое представление объекта

Escape-последовательность	Символ
`\н`	Новая строка
`\r`	Возврат каретки
`\r\n`	Возврат каретки + перевод строки
`\v` или `\x0b`	Строковая таблица
`\f` или `\x0c`	Подача страницы
`\x1c`	Разделитель файлов
`\x1d`	Разделитель групп
`\x1e`	Разделитель записей
`\x85`	Следующая строка (код управления C1)
`\u2028`	Разделитель строк Unicode
`\u2029`	Разделитель абзацев Юникода

Escape-последовательность	Описание
\новая строка	Обратная косая черта и новая строка игнорируются
\	Обратная косая черта
\'	Одинарная кавычка
\"	Двойная кавычка
\а	Звонок ASCII
\б	ASCII Backspace
\ф	ASCII Подача страниц
\н	Перевод строки ASCII
\r	Возврат каретки ASCII
\т	Горизонтальная вкладка ASCII
\v	Вертикальная вкладка ASCII
\ооо	Символ с восьмеричным значением ooo
\хЧЧ	Символ с шестнадцатеричным значением HH

Метод	Описание
добавить()	Добавляет элемент в набор
очистить()	Удаляет все элементы из набора
копирование()	Возвращает копию набора
разница()	Возвращает разницу двух или более наборов в виде нового набора
разность_обновление()	Удаляет все элементы другого набора из этого набора
отбросить()	Удаляет элемент из набора, если он является членом. (Ничего не делать, если элемента нет в наборе)
пересечение()	Возвращает пересечение двух наборов как новый набор
cross_update()	Обновляет набор пересечением себя и другого
isdisjoint()	Возвращает `Истинно` , если два набора имеют нулевое пересечение
issubset()	Возвращает `True` , если другой набор содержит этот набор
issuperset ()	Возвращает `True` , если этот набор содержит другой набор
поп()	Удаляет и возвращает произвольный элемент множества. Вызывает `KeyError` , если набор пуст
удалить()	Удаляет элемент из набора. Если элемент не является членом, вызывает ошибку `KeyError`
симметричная_разность()	Возвращает симметричную разность двух наборов в виде нового набора
симметричная_разница_обновление()	Обновляет набор с симметричной разностью себя и другого
объединение()	Возвращает объединение наборов в новый набор
обновление()	Обновляет набор объединением себя и других

Функция	Описание
все()	Возвращает `True` , если все элементы набора истинны (или если набор пуст).
любой()	Возвращает `True` , если любой элемент набора истинен. Если набор пуст, возвращает `False` .
перечислить()	Возвращает перечисляемый объект. Он содержит индекс и значение для всех элементов набора в виде пары.
лен()	Возвращает длину (количество элементов) в наборе.
макс()	Возвращает самый большой элемент в наборе.
мин()	Возвращает наименьший элемент в наборе.
отсортировано()	Возвращает новый отсортированный список из элементов набора (сам набор не сортируется).
сумма()	Возвращает сумму всех элементов набора.