Поиск символа или подстроки в строке

Доступ к словарям

Вы можете получить доступ к любому значению в словаре через ключ. Если ключ не найден, то выведется ошибка KeyError.

Рассмотрим, как использовать словарь.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict
'James'

Чтобы получить значение first_name, нужно использовать следующий синтаксис: dictionary_name. Теперь попробуем получить ключ, который не существует.

>>> sample_dict
Traceback (most recent call last):
Python Shell, prompt 118, line 1
builtins.KeyError: 'address'

Это не сработало. Мы попросили словарь предоставить значение, которого нет. Можно использовать ключевое слово Python in, чтобы спросить, есть ли ключ в словаре.

>>> 'address' in sample_dict
False
>>> 'first_name' in sample_dict
True

А также проверить, нет ли ключа в словаре, используя ключевое слово Python not:

>>> 'first_name' not in sample_dict
False
>>> 'address' not in sample_dict
True

Метод list.insert()

Аргументы метода list.insert(i,x):

• i – индекс, который нужно присвоить новому элементу.
• x – новый элемент, который нужно вставить в список.

В аквариуме появилась ещё одна рыба (например, anchovy)

Обратите внимание: на данный момент элементы списка fish указаны в алфавитном порядке. Потому элемент ‘anchovy’ нужно добавить не в конец, а в начало списка

Предыдущий метод не подходит – он добавляет элементы только в конец списка. Используйте метод list.insert():

Теперь индексы всех элементов обновятся (‘anchovy’ – 0, ‘barracuda’ – 1, ‘flounder’ – 5).

Попробуйте добавить в список ещё один элемент, damselfish. Соблюдая алфавитный порядок, добавить элемент нужно под индексом 3.

Работа со строками

Последнее обновление: 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)

НазадВперед

Методы подсчета

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

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

Запросите длину строки ss:

Строка «8host Blog!» содержит 11 символов.

Кроме переменных, метод len() может подсчитать длину любой заданной строки, например:

Метод len() подсчитывает общее количество символов в строке.

Метод str.count()может подсчитать, сколько раз в строке повторяется тот или иной символ. Запросите количество символов о в строке «8host Blog!».

Запросите другой символ:

Несмотря на то, что символ b присутствует в запрашиваемой строке, метод возвращает 0, поскольку он чувствителен к регистру. Чтобы вывести символы по нижнему регистру,  используйте метод str.lower().

Используйте метод str.count() на последовательность символов:

Подстрока likes встречается в вышеприведённой строке дважды.

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

Для примера запросите индекс символа o в строке ss:

Первый символ о в строке «8host Blog!» находится под индексом 2.

Попробуйте узнать индекс первого символа подстроки «likes» внутри строки likes:

Но в данной строке последовательность likes встречается дважды. Как узнать индекс первого символа второй последовательности likes? Методу str.find() можно задать второй параметр – индекс, с которого нужно начинать поиск.

5 функций для отладки

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

breakpoint

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

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

dir

Эта функция может использоваться в двух случаях:

• просмотр списка всех локальных переменных;
• просмотр списка всех атрибутов конкретного объекта.

Из примера можно увидеть локальные переменные сразу после запуска и после создания новой переменной .

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

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

vars

Эта функция является своего рода смесью двух похожих инструментов: и .

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

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

Перед использованием было бы неплохо сначала обратиться к .

type

Эта функция возвращает тип объекта, который вы ей передаете.

Тип экземпляра класса есть сам класс.

Тип класса — это его метакласс, обычно это .

Атрибут даёт тот же результат, что и функция , но рекомендуется использовать второй вариант.

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

Обратите внимание, что при проверке типов обычно вместо используется функция. Также стоит понимать, что в Python обычно не принято проверять типы объектов (вместо этого практикуется утиная типизация)

help

Если вы находитесь в Python Shell или делаете отладку кода с использованием , и хотите знать, как работает определённый объект, метод или атрибут, функция поможет вам.

В действительности вы, скорее всего, будете обращаться за помощью к поисковой системе. Но если вы уже находитесь в Python Shell, вызов будет быстрее, чем поиск документации в Google.

Произвольные выражения

Так как f-строки оцениваются по мере выражения, вы можете внести любую или все доступные выражения Python в них. Это позволит вам делать интересные вещи, например следующее:

Python

print(f»{2 * 37}»)
# Вывод: ’74’

1 2	print(f»{2 * 37}») # Вывод: ’74’

Также вы можете вызывать функции. Пример:

Python

def to_lowercase(input):
return input.lower()

name = «Eric Idle»

print(f»{to_lowercase(name)} is funny.»)
# Вывод: ‘eric idle is funny.’

1 2 3 4 5 6 7

defto_lowercase(input) returninput.lower() name=»Eric Idle» print(f»{to_lowercase(name)} is funny.») # Вывод: ‘eric idle is funny.’

Также вы можете вызывать метод напрямую:

Python

print(f»{name.lower()} is funny.»)
# Вывод: ‘eric idle is funny.’

1 2	print(f»{name.lower()} is funny.») # Вывод: ‘eric idle is funny.’

Вы даже можете использовать объекты, созданные из классов при помощи f-строки. Представим, что у вас есть следующий класс:

Python

class Comedian:
def __init__(self, first_name, last_name, age):
self.first_name = first_name
self.last_name = last_name
self.age = age

def __str__(self):
return f»{self.first_name} {self.last_name} is {self.age}.»

def __repr__(self):
return f»{self.first_name} {self.last_name} is {self.age}. Surprise!»

1 2 3 4 5 6 7 8 9 10 11

classComedian def__init__(self,first_name,last_name,age) self.first_name=first_name self.last_name=last_name self.age=age def__str__(self) returnf»{self.first_name} {self.last_name} is {self.age}.» def__repr__(self) returnf»{self.first_name} {self.last_name} is {self.age}. Surprise!»

Вы могли бы сделать следующее:

Python

new_comedian = Comedian(«Eric», «Idle», «74»)

print(f»{new_comedian}»)
# Вывод: ‘Eric Idle is 74.’

1 2 3 4

new_comedian=Comedian(«Eric»,»Idle»,»74″) print(f»{new_comedian}») # Вывод: ‘Eric Idle is 74.’

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

Строка, которая возвращается __str__() является неформальным строковым представлением объекта и должна быть читаемой. Строка, которую вернул __str__() — это официальное выражение и должно быть однозначным. При вызове str() и repr(), предпочтительнее использовать __str__() и __repr__() напрямую.

По умолчанию, f-строки будут использовать __str__(), но вы должны убедиться в том, что они используют __repr__(), если вы включаете флаг преобразования !r:

Python

print(f»{new_comedian}»)
# Вывод: ‘Eric Idle is 74.’

print(f»{new_comedian!r}»)
# Вывод: ‘Eric Idle is 74. Surprise!’

1 2 3 4 5

print(f»{new_comedian}») # Вывод: ‘Eric Idle is 74.’   print(f»{new_comedian!r}») # Вывод: ‘Eric Idle is 74. Surprise!’

Если вы хотите прочитать часть обсуждения, в результате которого f-strings поддерживают полные выражения Python, вы можете сделать это здесь.

Операторы сравнения

Оператор
Пример
Смысл
Результат

Эквивалентно

если значение равно значению , в противном случае

Не эквивалентно

если не равно и в противном случае

Меньше

если меньше чем , в противном случае

Меньше или равно

если меньше или равно , в противном случае

Больше

если больше , в противном случае

Больше или равно

если больше или равно , в противном случае

Вот примеры используемых операторов сравнения:

>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a <= b
True
>>> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a <= b
True
>>> a >= b
True

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

Равенство для значений с плавающей точкой

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

>>> x = 1.1 + 2.2
>>> x == 3.3
False

Бабах! Внутренние представления операндов сложения не совсем равны и , поэтому вы не можете полагаться на для точного сравнения с .

Предпочтительным способом определения того, являются ли два значения с плавающей точкой «равными», является вычисление того, находятся ли они близко друг к другу, с учетом некоторого допуска. Посмотрите на этот пример:

>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs(x - 3.3) < tolerance
True

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

Методы словарей Python

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

d.get(ключ)

Метод get() позволяет получить значение. Ему нужно указать ключ для поиска. Можно вернуть значение по умолчанию, если ключ не будет найден. По умолчанию это None:

>>> print(sample_dict.get('address'))
None
>>> print(sample_dict.get('address', 'Not Found'))
Not Found

Первый пример иллюстрирует, что происходит, если попытаться получить ключ, которого не существует без установки значения get по умолчанию. В этом случае метод возвращается None.

Во втором примере показано, как установить по умолчанию строку “Not Found”.

d.clear()

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

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict
{'email': 'jdoe@gmail.com', 'first_name': 'James', 'last_name': 'Doe'}
>>> sample_dict.clear()
>>> sample_dict
{}

d.copy()

Чтобы создать простую копию словаря, используется метод copy().

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> copied_dict = sample_dict.copy()
>>> copied_dict
{'email': 'jdoe@gmail.com', 'first_name': 'James', 'last_name': 'Doe'}

Если в словаре есть объекты или словари, то можно столкнуться с логическими ошибками. Так как изменение одного словаря может повлиять на его копию. В этом случае необходимо использовать модуль Python copy, в котором есть функция deepcopy(). Она создаетотдельную копию словаря.

d.Items()

Метод items() возвращает новое представление из элементов словаря.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.items()
dict_items()

Этот объект представления будет меняться по мере изменения самого словаря.

d.keys()

Чтобы получить представление ключей, которые есть в словаре, используется метод keys(). Он предоставляет динамическое представление ключей словаря. Можно представление, а также проверить принадлежность представлению по ключевому слову in.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> keys = sample_dict.keys()
>>> keys
dict_keys()
>>> 'email' in keys
True
>>> len(keys)
3

d.values()

Метод values() возвращает объект динамического представления значений словаря.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> values = sample_dict.values()
>>> values
dict_values()
>>> 'Doe' in values
True
>>> len(values)
3

d.pop(ключ)

Чтобы удалить ключ из словаря, используется метод pop(). Он принимает ключ и строку параметра по умолчанию. Если не установить значение по умолчанию и ключ не будет найден, то выведется ошибка KeyError.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.pop('something')
Traceback (most recent call last):
Python Shell, prompt 146, line 1
builtins.KeyError: 'something'
>>> sample_dict.pop('something', 'Not found!')
'Not found!'
>>> sample_dict.pop('first_name')
'James'
>>> sample_dict
{'email': 'jdoe@gmail.com', 'last_name': 'Doe'}

d.popitem()

Метод popitem() используется для удаления и возвращает пары ключ-значение из словаря в порядке «последним добавлен — первым удален». Если метод вызывается в пустом словаре, то отобразится KeyError.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.popitem()
('email', 'jdoe@gmail.com')
>>> sample_dict
{'first_name': 'James', 'last_name': 'Doe'}

d.update()

Метод обновляет словарь другими парами ключ-значение, перезаписывая существующие ключи. Возвращает None.

>>> sample_dict = {'first_name': 'James', 'last_name': 'Doe', 'email': 'jdoe@gmail.com'}
>>> sample_dict.update()
>>> sample_dict
{'email': 'jdoe@gmail.com',
'first_name': 'James',
'last_name': 'Doe',
'something': 'else'}

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

Каждому символу в строке соответствует индексный номер, начиная с 0. К примеру, строка 8host Blog! индексируется следующим образом:

8	h	o	s	t		B	l	o	g	!
1	2	3	4	5	6	7	8	9	10

Как видите, индексом первого символа является 0, последний индекс, 10, принадлежит символу «!».Любой другой символ или знак препинания (*#$&.;?,) также будет иметь свой собственный номер индекса.

Следует обратить внимание на то, что пробел также является частью строки, потому тоже имеет свой индекс (в данном случае 5). Принимая во внимание тот факт, что каждый символ в строке Python имеет соответствующий индекс, вы можете управлять строками так же, как и любыми другими последовательными типами данных

Принимая во внимание тот факт, что каждый символ в строке Python имеет соответствующий индекс, вы можете управлять строками так же, как и любыми другими последовательными типами данных

Поиск символа по положительному индексу

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

Когда вы ссылаетесь на конкретный индекс, Python возвращает символ, которому этот индекс принадлежит. Символ t в строке 8host Blog! имеет индекс 4.

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

К примеру, у вас есть очень длинная строка. Чтобы точно определить её конец, можно начать счёт в обратном порядке, начиная с конца строки и индекса -1.

К примеру, строка 8host Blog!будет иметь следующий негативный индекс:

8	h	o	s	t		B	l	o	g	!
-11	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1

Запросите символ с отрицательным индексом -9:

Отрицательный индекс позволяет выбрать символ в длинной строке.

Срез строк

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

Как можно понять из примера, 6 – индекс первого символа среза (включительно), а 10 – индекс символа после среза (по сути, в срез входят символы с индексами 6, 7, 8 и 9; восклицательный знак с индексом 10 уже не входит в срез).

Выполняя нарезку строки, вы создаёте новую строку, точнее, подстроку – строку, которая существует внутри другой строки (к примеру, строка Blog существует внутри строки 8host Blog!).

Чтобы включить в срез начало или конец строки, можно опустить индекс первого или последнего её символа. К примеру, чтобы вывести только 8host (первое слово строки), можно ввести:

Как видите, индекс первого символа не указан.

Чтобы вывести подстроку, начиная с середины строки и до конца, можно ввести:

Также в срезе можно использовать отрицательный индекс. Как говорилось в предыдущем разделе, отрицательная индексация начинается с -1 с конца строки, обратный отсчёт продолжается до первого символа строки.

Попробуйте запросить срез с помощью отрицательного индекса:

Срезы с шагом

В предыдущем разделе срез был взят по такому шаблону:

включая индекс start и не включая индекс stop. Однако срезы можно задавать по трём параметрам:

где stride – шаг. Этот параметр указывает, на сколько символов нужно продвинуться после взятия первого символа. По умолчанию шаг в Python равен 1, то есть, Python будет извлекать символы по порядку.

Шаг со стандартным значением 1 можно не указывать – это не повлияет на поведение Python. Например:

Стандартный шаг будет выводить каждый индекс. Попробуйте задать нестандартное значение шага:

Если шаг – 2, Python пропустить каждый второй символ и выведет символы исходной строки через один (выведенные символы выделены красным):

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

Попробуйте увеличить шаг:

Такой шаг выведет каждый четвертый символ после первого символа строки.

Запрашивая всю строку, вы можете не указывать первые два параметра (start и stop), так как при этом Python по умолчанию выводит строку от начала до конца.

print(ss)
8to

Также вы можете использовать отрицательные индексы. Шаг -1 выведет символы строки в обратном порядке:

Первые два параметра пропущены, потому Python выведет все символы строки.

Попробуйте запросить всю строку с шагом -2:

При этом символы строки будут выведены в обратном порядке через один:

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

capitalize()	Преобразует первый символ строки в верхний регистр	str_name.capitalize()
casefold()	Он преобразует любую строку в нижний регистр независимо от ее регистра	str_name.casefold()
center()	Используется для выравнивания строки по центру	str_name.center (длина, символ)
count()	Для подсчета количества раз, когда определенное значение появляется в строке.	str_name.count (значение, начало, конец)
endswith()	Проверяет, заканчивается ли строка указанным значением, затем возвращает True	str_name.endswith (значение, начало, конец)
find()	Используется для определения наличия указанного значения в строке	str_name.find (значение, начало, конец)
index()	Он используется для поиска первого вхождения указанного значения в строке	str_name.index (значение, начало, конец)
isalnum()	Проверяет, все ли символы являются буквенно-цифровыми, затем возвращает True	str_name.isalnum()
isalpha()	Проверяет, все ли символы являются алфавитными (az), затем возвращает True	str_name.isalpha()
isdecimal()	Проверяет, все ли символы являются десятичными (0-9), затем возвращает True	str_name.isdecimal()
isdigit()	Проверяет, все ли символы являются цифрами, затем возвращает True	str_name.isdigit()
islower()	Проверяет, все ли символы в нижнем регистре, затем возвращает True	str_name.islower()
isnumeric()	Проверяет, все ли символы являются числовыми (0-9), затем возвращает True	str_name.isnumeric()
isspace()	Проверяет, все ли символы являются пробелами, затем возвращает True	str_name.isspace()
isupper()	Проверяет, все ли символы в верхнем регистре, затем возвращает True	str_name.isupper()
lower()	Используется для преобразования всех символов в нижний регистр	str_name.lower()
partition()	Используется для разделения строки на кортеж из трех элементов.	str_name.partition (значение)
replace()	Используется для замены указанного слова или фразы другим словом или фразой в строке.	str_name.replace (старое значение, новое значение, количество)
split()	Используется для разделения строки на список	str_name.split (разделитель, maxsplit)
splitlines()	Используется для разделения строки и составления ее списка. Разбивается на разрыв строки.	str_name.splitlines (keeplinebreaks)
startswith()	Проверяет, начинается ли строка с указанного значения, затем возвращает True	str_name.startswith (значение, начало, конец)
strip()	Используется для удаления символов, указанных в аргументе, с обоих концов	str_name.strip (символы)
swapcase()	Используется для замены строки верхнего регистра на нижний регистр или наоборот.	str_name.swapcase()
title()	Преобразует начальную букву каждого слова в верхний регистр	str_name.title()
upper()	Он используется для преобразования всех символов в строке в верхний регистр	str_name.upper()

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

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

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

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

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