Работа со строками
Содержание:
- Что такое строка в Python?
- Вводная информация о строках
- Escape sequences
- Шаблоны и новая методика форматирования строк
- Задания для самоподготовки
- Форматирование строк в Python
- #4 Шаблонные строки (Стандартная библиотека Template Strings)
- Атрибут __doc__
- Как изменить или удалить строку?
- Строковые функции, методы и операторы
- Однострочные строки документации в Python
- Соединение строк в Python
- Операции со строками в Python
- String format()
- #2 Форматирование строк “По новому” (str.format)
- Замена в строке
- Обрабатываем строку в Python
- Используем расширенный синтаксис слайсинга
- Что насчёт поиска в строке?
- Работа со строками
Что такое строка в Python?
Строка в Python — это обычная последовательность символов (букв, цифр, знаков препинания).
Компьютеры не имеют дело с символами, они имеют дело с числами (в двоичной системе). Даже если вы видите символы на вашем экране, внутри памяти компьютера он хранится и обрабатываются как последовательность нулей и единиц.
Преобразование символа в число называется кодированием, а обратный процесс — декодированием. ASCII и Unicode — наиболее популярные из кодировок, которые используются для кодирования и декодирования данных.
В Python, строка — это последовательность символов Unicode. Юникод был введен для включения каждого символа на всех языках и обеспечения единообразия в кодировании.
Вводная информация о строках
Как и во многих других языках программирования, в Python есть большая коллекция функций, операторов и методов, позволяющих работать со строковым типом.
Литералы строк
Литерал – способ создания объектов, в случае строк Питон предлагает несколько основных вариантов:
Если внутри строки необходимо расположить двойные кавычки, и сама строка была создана с помощью двойных кавычек, можно сделать следующее:
Разницы между строками с одинарными и двойными кавычками нет – это одно и то же
Какие кавычки использовать – решать вам, соглашение PEP 8 не дает рекомендаций по использованию кавычек. Просто выберите один тип кавычек и придерживайтесь его. Однако если в стоке используются те же кавычки, что и в литерале строки, используйте разные типы кавычек – обратная косая черта в строке ухудшает читаемость кода.
Кодировка строк
В третьей версии языка программирования Python все строки представляют собой последовательность Unicode-символов.
В Python 3 кодировка по умолчанию исходного кода – UTF-8. Во второй версии по умолчанию использовалась ASCII. Если необходимо использовать другую кодировку, можно разместить специальное объявление на первой строке файла, к примеру:
Максимальная длина строки в Python
Максимальная длина строки зависит от платформы. Обычно это:
- 2**31 — 1 – для 32-битной платформы;
- 2**63 — 1 – для 64-битной платформы;
Константа , определенная в модуле
Конкатенация строк
Одна из самых распространенных операций со строками – их объединение (конкатенация). Для этого используется знак , в результате к концу первой строки будет дописана вторая:
При необходимости объединения строки с числом его предварительно нужно привести тоже к строке, используя функцию
Сравнение строк
При сравнении нескольких строк рассматриваются отдельные символы и их регистр:
- цифра условно меньше, чем любая буква из алфавита;
- алфавитная буква в верхнем регистре меньше, чем буква в нижнем регистре;
- чем раньше буква в алфавите, тем она меньше;
При этом сравниваются по очереди первые символы, затем – 2-е и так далее.
Далеко не всегда желательной является зависимость от регистра, в таком случае можно привести обе строки к одному и тому же регистру. Для этого используются функции – для приведения к нижнему и – к верхнему:
Как удалить строку в Python
Строки, как и некоторые другие типы данных в языке Python, являются неизменяемыми объектами. При задании нового значения строке просто создается новая, с заданным значением. Для удаления строки можно воспользоваться методом , заменив ее на пустую строку:
Или перезаписать переменную пустой строкой:
Обращение по индексу
Для выбора определенного символа из строки можно воспользоваться обращением по индексу, записав его в квадратных скобках:
Индекс начинается с 0
В Python предусмотрена возможность получить доступ и по отрицательному индексу. В таком случае отсчет будет вестись от конца строки:
Escape sequences
Backslashes may not appear inside the expression portions of
f-strings, so you cannot use them, for example, to escape quotes
inside f-strings:
>>> f'{\'quoted string\'}'
File "<stdin>", line 1
SyntaxError: f-string expression part cannot include a backslash
You can use a different type of quote inside the expression:
>>> f'{"quoted string"}'
'quoted string'
Backslash escapes may appear inside the string portions of an
f-string.
Note that the correct way to have a literal brace appear in the
resulting string value is to double the brace:
>>> f'{{ {4*10} }}'
'{ 40 }'
>>> f'{{{4*10}}}'
'{40}'
Like all raw strings in Python, no escape processing is done for raw
f-strings:
>>> fr'x={4*10}\n'
'x=40\\n'
Due to Python’s string tokenizing rules, the f-string
f'abc {a} def' is invalid. The tokenizer parses this as 3
tokens: f'abc {a[', x, and ']} def'. Just like regular
strings, this cannot be fixed by using raw strings. There are a number
of correct ways to write this f-string: with a different quote
character:
f"abc {a} def"
Or with triple quotes:
Шаблоны и новая методика форматирования строк
Этот метод был добавлен в Python 2.4 в виде шаблонов строк, но в качестве обычного метода string, работающего через метод format в версии 2.6. Так что это не самый свежий метод, просто обновленный. В любом случае, приступим к работе с шаблонами!
Python
print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!
| 1 | print(«%(lang)s is fun!»%{«lang»»Python»})# Python is fun! |
Должно быть это выглядит странно, но на самом деле мы сменили наши % на %(lang), с тем отличием, что данный объект идет в комплекте с переменной. Вторая часть пример вызывает словарь Python, который мы рассмотрим в следующей статье. В основном, это пара key:value, так что когда Python ищет ключ lang в строке и в указанном словаре ключей, он заменяет этот ключ его значением. Давайте взглянем на следующие примеры:
Python
a = «%(value)s %(value)s %(value)s !» % {«value»:»SPAM»}
print(a) # SPAM SPAM SPAM !
b = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2}
print(b)
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
KeyError: ‘z’
c = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2, «z»:3}
print(c) # 1 + 2 = 3
|
1 |
a=»%(value)s %(value)s %(value)s !»%{«value»»SPAM»} print(a)# SPAM SPAM SPAM ! b=»%(x)i + %(y)i = %(z)i»%{«x»1,»y»2} print(b) Traceback(most recent call last) File»<string>»,line1,in<fragment> KeyError’z’ c=»%(x)i + %(y)i = %(z)i»%{«x»1,»y»2,»z»3} print(c)# 1 + 2 = 3 |
В первом примере вы могли заметить, что мы передали только одно значение, но оно было вставлено три раза. Это одно из преимуществ использования шаблонов. Второй пример был загвоздкой, в которой мы забыли передать ключ z. В третьем примере эта проблема была исправлена с соответствующим результатом. Теперь давайте взглянем на то, что мы можем сделать, по аналогии с методом форматирования строк:
Python
a = «Python is as simple as {0}, {1}, {2}».format(«a», «b», «c»)
print(a) # ‘Python is as simple as a, b, c’
b = «Python is as simple as {1}, {0}, {2}».format(«a», «b», «c»)
print(b) # ‘Python is as simple as b, a, c’
xy = {«x»:0, «y»:10}
c = «Graph a point at where x={x} and y={y}».format(**xy)
print(c) # Graph a point at where x=0 and y=10
|
1 |
a=»Python is as simple as {0}, {1}, {2}».format(«a»,»b»,»c») print(a)# ‘Python is as simple as a, b, c’ b=»Python is as simple as {1}, {0}, {2}».format(«a»,»b»,»c») print(b)# ‘Python is as simple as b, a, c’ xy={«x»,»y»10} c=»Graph a point at where x={x} and y={y}».format(**xy) print(c)# Graph a point at where x=0 and y=10 |
В двух первых примерах вы можете увидеть, что мы можем передать объекты позиционно. Если мы перестроим порядок, мы получим немного другую выдачу. В последнем примере мы использовали словарь также, как мы использовали шаблоны ранее. Однако, нам нужно извлечь словарь при помощи двойной звездочки, чтобы он работал правильно. Существует множество других случаев, в которых используются строки, такие как определение ширины, выравнивание текста, конвертация в разные базы и многое другое. Убедитесь в том, что вы ознакомились с рекомендациями ниже, для дополнительной информации.
- Документация Python 2.Х о
Задания для самоподготовки
1. Написать
программу корректности ввода телефонного номера по шаблону:
x(xxx)xxxxxx
где x – любая цифра от
0 до 9. Данные представлены в виде строки.
2. Написать
программу изменения строки
«2+3+6.7 +
82 + 5.7 +1»
на строку, в
которой все «+» заменены на «-» и удалены все пробелы
3. Написать
программу вывода чисел 0; -100; 5.6; -3 в виде столбца:
0 -100 5.6 -3
в котором все
строки выровнены по правому краю (подсказка: воспользуйтесь методом rjust).
4. В строке «abrakadabra» найдите все
индексы подстроки «ra» и выведите их (индексы) в консоль.
Видео по теме
Python 3 #1: установка и запуск интерпретатора языка
Python 3 #2: переменные, оператор присваивания, типы данных
Python 3 #3: функции input и print ввода/вывода
Python 3 #4: арифметические операторы: сложение, вычитание, умножение, деление, степень
Python 3 #5: условный оператор if, составные условия с and, or, not
Python 3 #6: операторы циклов while и for, операторы break и continue
Python 3 #7: строки — сравнения, срезы строк, базовые функции str, len, ord, in
Python 3 #8: методы строк — upper, split, join, find, strip, isalpha, isdigit и другие
Python 3 #9: списки list и функции len, min, max, sum, sorted
Python 3 #10: списки — срезы и методы: append, insert, pop, sort, index, count, reverse, clear
Python 3 #11: списки — инструмент list comprehensions, сортировка методом выбора
Python 3 #12: словарь, методы словарей: len, clear, get, setdefault, pop
Python 3 #13: кортежи (tuple) и операции с ними: len, del, count, index
Python 3 #14: функции (def) — объявление и вызов
Python 3 #15: делаем «Сапер», проектирование программ «сверху-вниз»
Python 3 #16: рекурсивные и лямбда-функции, функции с произвольным числом аргументов
Python 3 #17: алгоритм Евклида, принцип тестирования программ
Python 3 #18: области видимости переменных — global, nonlocal
Python 3 #19: множества (set) и операции над ними: вычитание, пересечение, объединение, сравнение
Python 3 #20: итераторы, выражения-генераторы, функции-генераторы, оператор yield
Python 3 #21: функции map, filter, zip
Python 3 #22: сортировка sort() и sorted(), сортировка по ключам
Python 3 #23: обработка исключений: try, except, finally, else
Python 3 #24: файлы — чтение и запись: open, read, write, seek, readline, dump, load, pickle
Python 3 #25: форматирование строк: метод format и F-строки
Python 3 #26: создание и импорт модулей — import, from, as, dir, reload
Python 3 #27: пакеты (package) — создание, импорт, установка (менеджер pip)
Python 3 #28: декораторы функций и замыкания
Python 3 #29: установка и порядок работы в PyCharm
Python 3 #30: функция enumerate, примеры использования
Форматирование строк в Python
Экранирование символов
Если внутри строки содержатся символы одинарной и двойной кавычки, то вне зависимости от того, какие кавычки мы использовали для создания строки — мы получим ошибку SyntaxError.
>>> print("She said, "What's there?"")
...
SyntaxError: invalid syntax
>>> print('She said, "What's there?"')
...
SyntaxError: invalid syntax
Один из способов обойти эту проблему — использовать тройные кавычки. В качестве альтернативы мы можем использовать escape-последовательности или так называемое «экранирование символов».
Экранирующая последовательность начинается с обратной косой черты. Если мы используем одинарную кавычку для представления строки, все одинарные кавычки внутри строки должны быть экранированы. Аналогично обстоит дело с двойными кавычками. Вот как это можно сделать для представления приведенного выше текста.
# Тройные кавычки
print('''He said, "What's there?"''')
# Экранирование одинарных кавычек
print('He said, "What\'s there?"')
# Экранирование двойных кавычек
print("He said, \"What's there?\"")
Использование метода format() для форматирования строк
Метод format(), доступный для строкового объекта, очень универсален и мощен в форматировании строк. Формат строки содержит фигурные скобки {} в качестве заполнителей или заменяющих полей, которые заменяются соответствующими значениями.
Мы можем использовать позиционные аргументы или ключевые аргументы, чтобы указать порядок.
# порядок по умолчанию
default_order = "{}, {} and {}".format('John','Bill','Sean')
print(default_order)
# порядок задается вручную
positional_order = "{1}, {0} and {2}".format('John','Bill','Sean')
print(positional_order)
# порядок задается аргументами
keyword_order = "{s}, {b} and {j}".format(j='John',b='Bill',s='Sean')
print(keyword_order)
Метод format() может иметь необязательные спецификации формата. Они отделены от имени поля двоеточием. Например, мы можем выравнивать по левому краю <, выравнивать по правому краю > или центрировать ^ строку в заданном пространстве. Мы также можем отформатировать целые числа как двоичные, шестнадцатеричные и т.д., а числа с плавающей точкой могут быть округлены или отображены в формате экспоненты. Существует множество форматов, которые вы можете использовать. Более подробно про метод format() можно почитать в официальной документации к языку.
>>> # форматирование целых чисел
>>> "Binary representation of {0} is {0:b}".format(12)
'Binary representation of 12 is 1100'
>>> # форматирование чисел с плавающей запятой
>>> "Exponent representation: {0:e}".format(1566.345)
'Exponent representation: 1.566345e+03'
>>> # округление
>>> "One third is: {0:.3f}".format(1/3)
'One third is: 0.333'
>>> # выравнивание строки
>>> "|{:<10}|{:^10}|{:>10}|".format('butter','bread','ham')
'|butter | bread | ham|’
#4 Шаблонные строки (Стандартная библиотека Template Strings)
Рассмотрим еще один инструмент для форматирования строк в Python: template strings. Это более простой и менее мощный механизм, но в ряде случаев он может быть именно тем, что вам нужно.
Давайте посмотрим на простой пример:
Python
from string import Template
t = Template(‘Hey, $name!’)
print(t.substitute(name=name))
# Вывод: ‘Hey, Bob!’
|
1 |
fromstringimportTemplate t=Template(‘Hey, $name!’) print(t.substitute(name=name)) |
Вы видите, что нам нужно импортировать класс Template из встроенного модуля Python, под названием string. Эти шаблонные строки не являются особенностью корневого языка, но они поддерживаются модулем string в стандартной библиотеке.
Другое отличие заключается в том, что шаблонные строки не позволяют форматировать спецификаторы. Учитывая это, чтобы сделать предыдущий пример с ошибкой рабочим, вам нужно вручную изменить номер ошибки int в шестнадцатеричную строку:
Python
templ_string = ‘Hey $name, there is a $error error!’
print(
Template(templ_string).substitute(
name=name, error=hex(errno)
)
)
# Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’
|
1 |
templ_string=’Hey $name, there is a $error error!’ print( Template(templ_string).substitute( name=name,error=hex(errno) ) ) |
Это сработало отлично!
Так когда нам стоит использовать шаблонные строки в программах Python?
На мой взгляд, лучшее время для использования шаблонных строк — это когда вы обрабатываете форматированные строки, которые были созданы пользователями вашей программы. Учитывая их простоту, шаблонные строки — это безопасный выбор.
Более сложные мини-языки форматирования других техник форматирования строк может ослабить безопасность ваших программ и сделать их уязвимее. Например, строка форматирования может получить доступ к произвольным переменным в вашей программе.
Это значит, что злоумышленник может использовать форматную строку, которая (технически), может слить ключи безопасности и другую конфиденциальную информацию! Вот простой пример, подтверждающий то, как эта атака может быть использована против вашего кода:
Python
# Вот ваш супер-секретный ключ:
SECRET = ‘this-is-a-secret’
class Error:
def __init__(self):
pass
# Злоумышленник может создать форматную строку, которая
# может считать данные из общего словаря:
user_input = ‘{error.__init__.__globals__}’
# Это позволяет ему профильтровать конфиденциальную информацию
# такую, как секретный ключ:
err = Error()
print(user_input.format(error=err))
# Вывод: ‘this-is-a-secret’
|
1 |
# Вот ваш супер-секретный ключ: SECRET=’this-is-a-secret’ classError def__init__(self) pass user_input='{error.__init__.__globals__}’ err=Error() print(user_input.format(error=err)) |
Видите, как гипотетический злоумышленник может извлечь нашу секретную строку, получив доступ к словарю __globals__ из вредоносной строки форматирования?
Страшно, да? Шаблонные строки закрывают этот вектор атаки. Это делает их более безопасным выбором, если вы обрабатываете строки форматирования, созданные в вводе пользователя:
Python
print(user_input = ‘${error.__init__.__globals__}’)
print(Template(user_input).substitute(error=err))
ValueError:
«Invalid placeholder in string: line 1, col 1»
|
1 |
print(user_input=’${error.__init__.__globals__}’) print(Template(user_input).substitute(error=err)) ValueError «Invalid placeholder in string: line 1, col 1» |
Атрибут __doc__
Всякий раз, когда строковые литералы присутствуют сразу после определения функции, модуля, класса или метода, они становятся специальным атрибутом этого объекта. Позже мы можем использовать этот атрибут для получения этой строки документации.
Пример 2: Вывод на экран строки документации.
def square(n):
'''Принимает число n, возвращает квадрат числа n'''
return n**2
print(square.__doc__)
Результат:
Здесь мы получили доступ к документации нашей функции с помощью атрибута .
Теперь давайте посмотрим на строки документации для встроенной функции :
Пример 3: строки документации для встроенной функции print().
print(print.__doc__)
Результат:
Здесь мы можем видеть, что документация функции представлена как атрибут этой функции.
Как изменить или удалить строку?
Строки относятся к неизменяемым типам данных (immutable type). Это означает, что элементы строки не могут быть изменены после того, как она была создана. Мы можем просто переназначить разные строки одному и тому же имени.
>>> my_string = 'programfiles' >>> my_string = 'a' ... TypeError: 'str' object does not support item assignment >>> my_string = 'Python' >>> my_string ‘Python'
Мы не можем удалять символы из строки. Но полностью удалить строку можно с помощью ключевого слова del.
>>> del my_string ... TypeError: 'str' object doesn't support item deletion >>> del my_string >>> my_string ... NameError: name 'my_string' is not defined
Строковые функции, методы и операторы
Строки являются последовательностями, а последовательности в языке Python образуют целый класс типов данных, который объединяет наличие общих свойств, а следовательно, общих функций и операторов. Например списки – это последовательности объектов, доступ к которым так же осуществляется по их индексу:
Списки, так же как и строки могут «складываться» (соединяться) и «умножаться» (дублироваться):
Для определения длины строк, списков и прочих последовательностей, можно воспользоваться функцией :
Операторы и позволяют выяснить наличие или отсутствие в последовательности некоторого элемента:
С помощью оператора можно осуществлять перебор всех элементов любой последовательности в цикле :
Поскольку работа с текстовыми данными занимает значительную часть повседневной деятельности, то неудивительно, что строки обзавелись большим количеством встроенных методов, которые позволяют выполнять самые распространенные действия над ними. Вот лишь малая часть этих методов:
Что бы посмотреть на список всех доступных строкам функций и методов достаточно передать функции какой-нибудь строковый объект:
Мы не спроста, воспользовались модулем так как простая команда привела бы к выводу длинного списка в виде одной длинной строки. Имейте ввиду, что данный модуль может оказаться очень полезным для организации удобочитаемого вывода данных и в некоторых ситуациях, гораздо проще воспользоваться именно им, чем ломать голову над форматированием строки для удобочитаемого вывода.
Однострочные строки документации в Python
Однострочные строки документации должны помещаться на одной строке.
Стандартные соглашения для написания однострочных строк документации:
- Несмотря на то, что они однострочные, мы по-прежнему используем тройные кавычки вокруг этих строк документации, тогда их можно будет легко расширить позже.
- Закрывающие кавычки находятся на той же строке, что и открывающие кавычки.
- Не нужно добавлять пустую строку ни перед, ни после строки документации.
- Они не должны быть описательными, скорее они должны следовать структуре «Делает это, возвращает это», заканчивающейся точкой.
Давайте посмотрим на пример ниже.
Пример 4: Однострочная строка документации для функции.
def multiplier(a, b):
"""Принимает два числа, возвращает их произведение."""
return a*b
Соединение строк в Python
Рассматривая простейшие операции со строками, мы увидели, как объединяются строки через операцию сложения. Однако есть и другая возможность для соединения строк — метод join():, объединяющий списки строк. В качестве разделителя используется текущая строка, у которой вызывается этот метод:
words = "Let", "me", "speak", "from", "my", "heart", "in", "English" # символ разделителя - пробел sentence = " ".join(words) print(sentence) # Let me speak from my heart in English # символ разделителя - вертикальная черта sentence = " | ".join(words) print(sentence) # Let | me | speak | from | my | heart | in | English
А если вместо списка в метод join передать простую строку, разделитель будет вставляться уже между символами:
word = "hello" joined_word = "|".join(word) print(joined_word) # h|e|l|l|o
Операции со строками в Python
Есть много операций, которые могут быть выполнены со строкой, что делает ее одним из наиболее часто используемых типов данных в Python.
Конкатенация двух или более строк
Объединение двух или более строк в одну называется конкатенацией. В Python конкатенация выполняется оператором +.
Оператор * может использоваться для повторения строки в течение заданного числа раз.
str1 = 'Hello'
str2 ='World!'
# Конкатенация (объединение) строк
print('str1 + str2 = ', str1 + str2)
# Повторение строк
print('str1 * 3 =', str1 * 3)
Перебор строк
Используя цикл for, мы можем перебирать строку.
Пример для подсчета количества символа ‘l’ в строке.
count = 0
for letter in 'Hello World':
if(letter == 'l'):
count += 1
print(count)
Проверка на наличие символа в строке
Мы можем проверить, существует ли подстрока в строке или нет, используя ключевое слово in.
>>> 'a' in 'programfiles' True >>> 'at' not in 'programfiles' False
String format()
The method allows you to format selected parts of a string.
Sometimes there are parts of a text that you do not control, maybe
they come from a database, or user input?
To control such values,
add placeholders (curly brackets ) in the text, and run the values through the
method:
Example
Add a placeholder where you want to display the price:
price = 49txt = «The price is {} dollars»print(txt.format(price))
You can add parameters inside the curly brackets to specify how to convert
the value:
Example
Format the price to be displayed as a number with two decimals:
txt = «The price is {:.2f} dollars»
Check out all formatting types in our String format() Reference.
#2 Форматирование строк “По новому” (str.format)
Python 3 предоставил новый способ форматирования, который также был внесен в раннюю версию Python 2.7. Этот “новый стиль” форматирования строк избавляется от специального синтаксиса оператора % и делает синтаксис для форматирования строк более регулярным. Теперь форматирование обрабатывается вызовом .format() в объекте строки.
Вы можете использовать format(), чтобы выполнить простое позиционное форматирование, также, как мы делали это по старинке:
Python
print(‘Hello, {}’.format(name))
# Вывод: ‘Hello, Bob’
|
1 |
print(‘Hello, {}’.format(name)) # Вывод: ‘Hello, Bob’ |
Или, вы можете сослаться на свои подстановки переменных по имени, и использовать их в том порядке, в котором вам хочется. Это достаточно мощный способ, так как он позволяет повторно упорядочить порядок отображения без изменения переданных функции format() аргументов:
Python
print(
‘Hey {name}, there is a 0x{errno:x} error!’.format(
name=name, errno=errno
)
)
# Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’
|
1 |
print( ‘Hey {name}, there is a 0x{errno:x} error!’.format( name=name,errno=errno ) ) |
Однако, официальная документация Python 3 не делает явных рекомендаций по использованию старого форматирования:
По этому я лично пытаюсь работать str.format при продвижении нового кода. Начав с Python 3.6, есть еще один способ форматирования ваших строк. Рассмотрим его в следующем разделе!
Замена в строке
Чтобы в Python заменить в строке одну подстроку на другую, применяют метод replace():
• replace(old, new): подстрока old заменяется на new;
• replace(old, new, num): параметр num показывает, сколько вхождений подстроки old требуется заменить на new.
Пример замены в строке в Python:
phone = "+1-234-567-89-10"
# дефисы меняются на пробелы
edited_phone = phone.replace("-", " ")
print(edited_phone) # +1 234 567 89 10
# дефисы удаляются
edited_phone = phone.replace("-", "")
print(edited_phone) # +12345678910
# меняется только первый дефис
edited_phone = phone.replace("-", "", 1)
print(edited_phone) # +1234-567-89-10
Обрабатываем строку в Python
Представим, что ожидается ввод числа с клавиатуры. Перед преобразованием введенной нами строки в число можно легко проверить, введено ли действительно число. Если это так, выполнится операция преобразования. Для обработки строки используем такой метод в Python, как isnumeric():
string = input("Введите какое-нибудь число: ")
if string.isnumeric():
number = int(string)
print(number)
Следующий пример позволяет удалять пробелы в конце и начале строки:
string = " привет мир! " string = string.strip() print(string) # привет мир!
Так можно дополнить строку пробелами и выполнить выравнивание:
print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))
В консоли Python будет выведено следующее:
iPhone 7 52000 Huawei P10 36000
Используем расширенный синтаксис слайсинга
# Python code to reverse a string
# using extended slice syntax
# Function to reverse a string
def reverse(string):
string = string
return string
s = "Pythonist"
print ("The original string is : ",end="")
print (s)
print ("The reversed string(using extended slice syntax) is : ",end="")
print (reverse(s))
The original string is : Pythonist The reversed string(using extended slice syntax) is : tsinohtyP
Объяснение: Расширенный срез предлагает поместить поле «шаг» в срез , а пустое поле в качестве начала и конца указывает по умолчанию на 0, а с шагом в -1 срез соберет как раз перевернутую исходную строку.
Что насчёт поиска в строке?
Самое быстрое — проверить, начинается ли (заканчивается ли) строка с выбранных символов. Для этого в Python предусмотрены специальные строковые методы.
Для поиск подстроки в произвольном месте есть метод с говорящим названием . Он вернет индекс начала найденного вхождения подстроки в строку, либо -1, если ничего не найдено.
Для сложных случаев, когда нужно найти не конкретную последовательность символов, а некий шаблон, помогут регулярные выражения. Они заслуживают отдельной статьи. Глубокого знания регулярок на собеседованиях не требуется, достаточно знать про них, уметь написать несложное выражение и прочитать чуть более сложное. Например, такое:
Работа со строками
Последнее обновление: 02.05.2017
Строка представляет последовательность символов в кодировке Unicode. И мы можем обратиться к отдельным символам строки по индексу в квадратных скобках:
string = "hello world" c0 = string # h print(c0) c6 = string # w print(c6) c11 = string # ошибка IndexError: string index out of range print(c11)
Индексация начинается с нуля, поэтому первый символ строки будет иметь индекс 0. А если мы попытаемся обратиться к индексу, которого нет в строке, то
мы получим исключение IndexError. Например, в случае выше длина строки 11 символов, поэтому ее символы будут иметь индексы от 0 до 10.
Чтобы получить доступ к символам, начиная с конца строки, можно использовать отрицательные индексы. Так, индекс -1 будет представлять последний символ, а -2 — предпоследний символ и так далее:
string = "hello world" c1 = string # d print(c1) c5 = string # w print(c5)
При работе с символами следует учитывать, что строка — это неизменяемый (immutable) тип, поэтому если мы попробуем изменить какой-то отдельный символ строки, то мы получим
ошибку, как в следующем случае:
string = "hello world" string = "R"
Мы можем только полностью переустановить значение строки, присвоив ей другое значение.
Получение подстроки
При необходимости мы можем получить из строки не только отдельные символы, но и подстроку. Для этого используется следующий синтаксис:
-
: извлекается последовательность символов начиная с 0-го индекса по индекс end
-
: извлекается последовательность символов начиная с индекса start по индекс end
-
: извлекается последовательность символов начиная с индекса start по индекс end через шаг step
Используем все варианты получения подстроки:
string = "hello world" # с 0 до 5 символа sub_string1 = string print(sub_string1) # hello # со 2 до 5 символа sub_string2 = string print(sub_string2) # llo # со 2 по 9 символ через один символ sub_string3 = string print(sub_string3) # lowr
Функции ord и len
Поскольку строка содержит символы Unicode, то с помощью функции ord() мы можем получить числовое значение для символа в кодировке Unicode:
print(ord("A")) # 65
Для получения длины строки можно использовать функцию len():
string = "hello world" length = len(string) print(length) # 11
Поиск в строке
С помощью выражения можно найти подстроку term в строке string. Если подстрока найдена, то выражение вернет значение
, иначе возвращается значение :
string = "hello world" exist = "hello" in string print(exist) # True exist = "sword" in string print(exist) # False
Перебор строки
С помощью цикла for можно перебрать все символы строки:
string = "hello world"
for char in string:
print(char)
НазадВперед
