Разное

Срезы строк python: Python 3: индексы и срезы строк

Содержание

Python 3: индексы и срезы строк

На самом деле в Python строка
представляются как упорядоченная коллекция символов. И ключевое слово здесь –
«упорядоченная». Это значит, что у каждого символа в строке есть свой
порядковый номер – индекс, по которому мы можем его получить. Например, когда
мы создаем строку

то формируется
следующая коллекция:

Каждый символ
имеет свой индекс, начиная с нулевого. Первый символ в Python всегда имеет
нулевой индекс.

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

<строка>[<индекс>]

Например:

и так далее. Но,
если указать неверный индекс, например:

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

lastIndex = len(<строка>)
– 1

То есть, к
последнему индексу мы можем обратиться так:

Но это не очень
удобно. Поэтому разработчики языка Python решили, что
отрицательные индексы будут означать движение по строке с конца в начало. И
предыдущую запись можно переписать так:

Видите? Это
намного удобнее. То есть, у строк есть еще такие отрицательные индексы:

Также в Python можно
использовать доступ к отдельному символу непосредственно у строкового литерала:

Иногда это
бывает удобно.

Срезы

Часто в программировании
требуется выбрать не один какой-то символ, а сразу несколько. Для этого
используются так называемые срезы. Их работу проще показать на конкретных
примерах. Пусть у нас есть наша строка:

и мы хотим
выделить последнее слово «World!». Для этого в квадратных скобках
указывается начальный индекс и через двоеточие – конечный. Если мы запишем все
вот в таком виде:

то получим
результат «World» без
восклицательного знака. Дело в том, что последний индекс исключается из
интервала, то есть, интервал определяется как

[6: 11)

Поэтому, мы
должны записать срез так:

Другой пример
для выделения символов «llo»:

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

выделяет слово «Hello», а вот так:

получим «World!». Наконец,
записав все в таком виде:

получим ту же
самую строку, не копию! Это можно проверить так:

copy = msg[:]
print(id(copy), id(msg))

Увидим одно и то же значение id для обеих переменных, это означет, что они ссылаются на один и тот же объект.

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

мы здесь ставим
еще одно двоеточие и указываем шаг 2, то есть, идем через символ: «HloWrd». Также
это можно комбинировать с граничными значениями:

msg[:5:2]
msg[6::2]
msg[1:6:2]

и использовать
отрицательный шаг:

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

Строка – неизменяемый объект

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

приведет к
ошибке, говорящая о том, что строка не может быть изменена. Тогда как в Python нам изменять
строки? Для этого создается новая строка с нужным содержимым. Например, изменим
строку

«Hello World!»

на строку

«Hello word!»

Это можно
сделать так:

myStr = msg[:6]+"w"+msg[7:9]+msg[10:]

В результате
строка myStr ссылается на
новую измененную строку, а msg осталась прежней.

Задания для самоподготовки

1. Напишите
программу подсчета букв ‘a’ в строке «abrakadabra».

2. Из строки «abrakadabra» удалите все
сочетания «ab».

3. Напишите
программу определения слова палиндрома (это слова, которые одинаково читаются в
обоих направлениях, например, анна, abba и т.п.). Слово
вводится с клавиатуры.

4. Напишите
программу определения количества вхождений фраз «ra» в слове «abrakadabra».

5. Разделите
введенное с клавиатуры предложение на слова (слова разделяются пробелом).

Индексы и срезы в Python

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


Индекс строки в Python


Строка представляет собой упорядоченный набор символов. Это значит, что каждый символ в строке занимает свое место — индекс. Например, у строки ‘string’, символ ‘s’ имеет индекс 0 и далее по порядку:


  • s — 0
  • t — 1
  • r — 2
  • i — 3
  • n — 4
  • g — 5

Первый по счету символ в строке всегда будет иметь индекс 0. Таким образом, обратившись по индексу к элементу, мы можем узнать его значение. В чем и состоит смысл индексов. У пробела, так же есть индекс.


Так мы получим всю строку целиком:




get_str = 'это строка'

print(get_str)

это строка

А здесь, обратившись по индексу 5, получаем его значение — символ ‘t’.




get_s = 'это строка'

print(get_s[5])

t

При обращении к несуществующему индексу, программа выведет ошибку.




get_s = 'это строка'

print(get_s[10])

IndexError: string index out of range

Отрицательный индекс


Мы знаем точно, что у первого символа строки всегда будет индекс 0. А как насчет последнего символа? Ведь длина строки не всегда заранее известна. Для закрепления постоянного индекса для последнего символа, Python вводит понятие отрицательного индекса и предлагает вести отсчет наоборот, справа налево.


P  y  t  h  o  n

-6 -5 -4 -3 -2 -1



get_last = 'Python'

print(get_last[-1])

n

Срез строки в Python


Иногда требуется получить из строки не один символ, а сразу несколько по некоторой закономерности — первые 2, каждый 3-ий или 4 последних. Для этого существуют срезы. Мы выборочно срезаем нужные символы и обращаемся по срезу. Надо отметить, что физически срезанные символы, остаются на своих местах. Сама строка никоим образом не меняется, мы работаем со срезанными копиями.


Возьмем первые три символа у строки ‘срезы Python’. В параметрах передадим два индекса — начало и конец среза. При срезе первый индекс входит включительно, а второй индекс не входит в выборку.




slice = 'срезы Python'

print(slice[0:3])

сре #символ 'з' не попал в выборку

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




slice = 'срезы Python'

print(slice[6:])

Python #с индекса 6 и до конца

slice = 'срезы Python'

print(slice[:5])

срезы #с начала строки до 5-го индекса включительно

slice = 'срезы Python'

print(slice[:])

срезы Python #выводит строку целиком


Третьим параметром у срезов, может передаваться шаг.




slice = 'срезы Python'

print(slice[::2])

сеыPto #выводит символы через один

Индекс списка в Python


Список — это упорядоченная коллекция нумерованных элементов, где первый элемент начинается с нулевой позиции. Когда мы обратимся к 4-ому элементу, то получим 12.




a = [2, 3, 5, 9, 12, 16]

print(a[4])

12

Правила для индексов у списка, похожие для индексов у строк:


  • обращение к несуществующему элементу, выведет ошибку
  • первый индекс равен 0, а последний индекс -1

Заменить элемент в списке


Существует принципиальная разница — элементы в списках в отличие от элементов в строках можно заменять, удалять или добавлять. Мы обращаемся по индексу в 3-му элементу в списке d и присваиваем индексу новое значение. В результате произошла замена — 7 поменялась на 10.




d = [1, 3, 5, 7, 8]

d[3] = 10

print(d)

[1, 3, 5, 10, 8]

Удалить элемент из списка


Элемент со значением 15 под индексом 2, вылетел из списка.




f = [11, 13, 15, 17]

del f[2]

print(f)

[11, 13, 17]

Срез списка в Python


Со срезами у списков дело обстоит точно так же, как и у строк. Делаем выборку со 2-го индекса по 4-ый, не включая сам 4-ый индекс.




b = [21, 32, 54, 90, 22, 46]

print(b[2:4])

[54, 90]

Вывод четных элементов списка


Выведем все четные элементы списка, используя срезы. Первым параметром передаем 1-ый индекс, во втором параметре пишем двоеточие (по умолчанию выведется последний элемент списка) и третьим параметром указываем шаг для выводимых элементов.




c = [21, 22, 23, 24, 25, 26, 27]

print(c[1::2])

[22, 24, 26]

Итоги


Ранее мы научились создавать строку, узнали, какие у строк есть методы. Сегодня вы научились по индексам и срезам находить значения. Но на этом, познания о строках не заканчиваются и все самое интересное, вас ждет впереди.


  • Создано 08.11.2019 10:03:33



  • Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Python 3 #10: списки — срезы и методы: append, insert, pop, sort, index, count, reverse, clear

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

lst = ["Москва", "Санкт-Петербург", "Тверь", "Казань"]

Используя
синтаксис:

список[start:end]

можно выделять
элементы, начиная с индекса start и заканчивая, но не включая индекс end. В частности,
вот такая конструкция:

возвратит список
из двух городов:

<p align=center>['Санкт-Петербург', 'Тверь']

То есть, здесь
создается новый объект list, содержащий эти элементы:

Прежний список lst не меняется. Если
индексы принимают отрицательные значение, то отсчет идет с конца списка:

получим

[‘Тверь’]

так как индекс
-1 – последний элемент не включается, остается только «Тверь». Или, можно записать
так:

тогда возьмем с
первого элемента и до предпоследнего:

[‘Москва’, ‘Санкт-Петербург’, ‘Тверь’]

У срезов можно записывать
любые числовые индексы к ошибкам это не приведет. Например:

вернет список со
2-го элемента и по последний:

[‘Санкт-Петербург’, ‘Тверь’, ‘Казань’]

Этот же
результат можно получить и так:

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

то элементы
выбираются с самого начала и до третьего индекса, то есть, получим:

[‘Москва’,
‘Санкт-Петербург’, ‘Тверь’]

Если не
указывать ни начало, ни конец, то будет возвращен список:

Спрашивается:
создает ли данная операция копию списка? Да, создается и в этом легко
убедиться, записав такие строчки:

c = lst[:]
print(id(c), id(lst))

И мы увидим разные
значения id, которые
говорят, что обе переменные ссылаются на разные списки. Также копию списка, можно
сделать с помощью функции-конструктора list:

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

получим:

[‘Москва’, ‘Тверь’]

Или, такие
варианты:

lst[1:4:2]
lst[:4:3]
lst[1::2]

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

Так как список –
это изменяемый объект, то мы можем срезам присваивать новые значения. Делается
это таким образом:

lst[1:3] = "Владимир", "Астрахань"

В результате,
получаем список:

[‘Москва’, ‘Владимир’,
‘Астрахань’, ‘Казань’]

Или даже так.
Большему срезу присвоить меньшее число элементов:

lst[0:3] = 'Пермь', 'Пенза'

В итоге получаем
список:

[‘Пермь’,
‘Пенза’, ‘Казань’]

Однако, если нам
нужно просто удалить какой-либо элемент, то это делается с помощью оператора del:

В результате
будет удален элемент с индексом 1 из списка lst:

[‘Пермь’,
‘Казань’]

Методы списков

Давайте теперь
предположим, что у нас имеется список из чисел:

a = [1, -54, 3, 23, 43, -45, 0]

и мы хотим в
конец этого списка добавить значение. Это можно сделать с помощью метода:

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

категорически не
следует, так мы только потеряем весь наш список! И этим методы списков
отличаются от методов строк, когда мы записывали:

string="Hello"
string = string.upper()

Здесь метод upper возвращает
измененную строку, поэтому все работает как и ожидается. А метод append ничего не
возвращает, и присваивать значение None переменной a не имеет
смысла, тем более, что все работает и так:

a = [1, -54, 3, 23, 43, -45, 0]
a.append(100)

Причем, мы в методе
append можем записать
не только число, но и другой тип данных, например, строку:

тогда в конец
списка будет добавлен этот элемент. Или, булевое  значение:

Или еще один
список:

И так далее. Главное,
чтобы было указано одно конкретное значение. Вот так работать не будет:

Если нам нужно
вставить элемент в произвольную позицию, то используется метод

Здесь мы
указываем индекс вставляемого элемента и далее значение самого элемента.

Следующий метод remove удаляет элемент
по значению:

a.remove(True)
a.remove('hello')

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

то возникает
ошибка. Еще один метод для удаления

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

Также в этом
методе можно указывать индекс удаляемого элемента, например:

Если нам нужно
очистить весь список – удалить все элементы, то можно воспользоваться методом:

Получим пустой
список. Следующий метод

a = [1, -54, 3, 23, 43, -45, 0]
c = a.copy()

возвращает копию
списка. Это эквивалентно конструкции:

В этом можно
убедиться так:

и список c будет отличаться
от списка a.

Следующий метод count позволяет найти
число элементов с указанным значением:

Если же нам
нужен индекс определенного значения, то для этого используется метод index:

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

Здесь поиск
будет начинаться с индекса 1, то есть, со второго элемента. Или, так:

Ищем число 23 с
1-го индекса и по 5-й не включая его. Если элемент не находится

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

и при значении True далее уже
определять индекс этого элемента.

Следующий метод

меняет порядок
следования элементов на обратный.

Последний метод,
который мы рассмотрим, это

выполняет
сортировку элементов списка по возрастанию. Для сортировки по убыванию, следует
этот метод записать так:

Причем, этот
метод работает и со строками:

lst = ["Москва", "Санкт-Петербург", "Тверь", "Казань"]
lst.sort()

Здесь
используется лексикографическое сравнение, о котором мы говорили, когда
рассматривали строки.

Это все основные
методы списков и чтобы вам было проще ориентироваться, приведу следующую
таблицу:












Метод

Описание

append()

Добавляет
элемент в конец списка

insert()

Вставляет
элемент в указанное место списка

remove()

Удаляет
элемент по значению

pop()

Удаляет
последний элемент, либо элемент с указанным индексом

clear()

Очищает
список (удаляет все элементы)

copy()

Возвращает
копию списка

count()

Возвращает
число элементов с указанным значением

index()

Возвращает
индекс первого найденного элемента

reverse()

Меняет
порядок следования элементов на обратный

sort()

Сортирует
элементы списка

Задания для самоподготовки

1. Пользователь
вводит с клавиатуры числа, до тех пор, пока не введет число 0. На основе
введенных данных нужно сформировать список, состоящий из квадратов введенных
чисел.

2. Написать
программу удаления из списка

[‘+7912123456’,
‘+7915213456’, ‘+6915213456’, ‘+4915213456’, ‘+7915213456’]

всех номеров с
кодом «+7».

3. Написать
программу циклического сдвига элементов списка влево. Например, дан список:

[1,2,3,4,5,6]

после сдвига на
один элемент влево, должны получить:

[2,3,4,5,6,1]

Реализовать
через цикл, перебирая все элементы.

4. Написать
аналогичную программу циклического сдвига, но теперь вправо.

Индексы и срезы | Python 3 для начинающих и чайников

Сегодня мы поговорим об операциях взятия индекса и среза.

Взятие элемента по индексу

Как и в других языках программирования, взятие по индексу:

>>> a = [1, 3, 8, 7]
>>> a[0]
1
>>> a[3]
7
>>> a[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Как и во многих других языках, нумерация элементов начинается с нуля. При попытке доступа к несуществующему индексу возникает исключение IndexError.

В данном примере переменная a являлась списком, однако взять элемент по индексу можно и у других типов: строк, кортежей.

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

>>> a = [1, 3, 8, 7]
>>> a[-1]
7
>>> a[-4]
1
>>> a[-5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Срезы

В Python, кроме индексов, существуют ещё и срезы.

item[START:STOP:STEP] — берёт срез от номера START, до STOP (не включая его), с шагом STEP. По умолчанию START = 0, STOP = длине объекта, STEP = 1. Соответственно, какие-нибудь (а возможно, и все) параметры могут быть опущены.

>>> a = [1, 3, 8, 7]
>>> a[:]
[1, 3, 8, 7]
>>> a[1:]
[3, 8, 7]
>>> a[:3]
[1, 3, 8]
>>> a[::2]
[1, 8]

Также все эти параметры могут быть и отрицательными:

>>> a = [1, 3, 8, 7]
>>> a[::-1]
[7, 8, 3, 1]
>>> a[:-2]
[1, 3]
>>> a[-2::-1]
[8, 3, 1]
>>> a[1:4:-1]
[]

В последнем примере получился пустой список, так как START < STOP, а STEP отрицательный. То же самое произойдёт, если диапазон значений окажется за пределами объекта:

>>> a = [1, 3, 8, 7]
>>> a[10:20]
[]

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

>>> a = [1, 3, 8, 7]
>>> a[1:3] = [0, 0, 0]
>>> a
[1, 0, 0, 0, 7]
>>> del a[:-3]
>>> a
[0, 0, 7]

Обработка строк в Python

В Python существуют несколько видов данных. Основные типы данных, с которыми вы столкнетесь – это string, ingteger, float, list, dict и tuple. В данной статье мы рассмотрим тип данных string (строка). Вы удивитесь тому, сколько всего можно делать со строками в Python. Также существует модуль string, который можно импортировать для получения доступа к еще большим возможностям, но мы рассмотрим его в другой статье. Вместо этого, мы пройдемся по следующим разделам:

  • Как создавать строки
  • Конкатенация строк
  • Методы строк
  • Замена строк

Как создать строку

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

my_string = «Добро пожаловать в Python!»
another_string = ‘Я новый текст тут…’

a_long_string = »’А это у нас
новая строка
в троичных скобках»’



my_string = «Добро пожаловать в Python!»

another_string = ‘Я новый текст тут…’

 

a_long_string = »’А это у нас

новая строка

в троичных скобках»’

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

my_string = «I’m a Python programmer!»
otherString = ‘Слово «Python» обычно подразумевает змею’
tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»



my_string = «I’m a Python programmer!»

otherString = ‘Слово «Python» обычно подразумевает змею’

tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

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

my_number = 123
my_string = str(my_number)



my_number = 123

my_string = str(my_number)

Если вы впишете данный код в ваш интерпретатор, вы увидите, что вы изменили значение интегратора на строку и присвоили ее переменной my_string. Это называется кастинг, или конвертирование. Вы можете конвертировать некоторые типы данных в другие, например числа в строки. Но вы также заметите, что вы не всегда можете делать обратное, например, конвертировать строку вроде ‘ABC’ в целое число. Если вы сделаете это, то получите ошибку вроде той, что указана в этом примере:

int(‘ABC’)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
ValueError: invalid literal for int() with base 10: ‘ABC’



int(‘ABC’)

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

ValueError: invalid literal for int() with base 10: ‘ABC’

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

То все должно работать. Обратите внимание на то, что строка – это один из неизменных типов Python. Это значит, что вы не можете менять содержимое строки после ее создания. Давайте попробуем сделать это и посмотрим, что получится:

my_string = «abc»
my_string[0] = «d»

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: ‘str’ object does not support item assignment



my_string = «abc»

my_string[0] = «d»

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: ‘str’ object does not support item assignment

Здесь мы пытаемся изменить первую букву с «а» на «d«, в итоге это привело к ошибке TypeError, которая не дает нам сделать это. Теперь вы можете подумать, что присвоение новой строке то же значение и есть изменение строки. Давайте взглянем, правда ли это:

my_string = «abc»
a = id(my_string)
print(a) # 19397208

my_string = «def»
b = id(my_string)
print(b) # 25558288

my_string = my_string + «ghi»
c = id(my_string)
print(c) # 31345312



my_string = «abc»

a = id(my_string)

print(a) # 19397208

 

my_string = «def»

b = id(my_string)

print(b) # 25558288

 

my_string = my_string + «ghi»

c = id(my_string)

print(c) # 31345312

Проверив id объекта, мы можем определить, что когда мы присваиваем новое значение переменной, то это меняет тождество. Обратите внимание, что в версии Python, начиная с 2.0, строки могут содержать только символы ASCII. Если вам нужен Unicode, тогда вы должны вписывать u перед вашей строкой. Пример:

# -*- coding: utf-8 -*-
my_unicode_string = u»Это юникод!»



# -*- coding: utf-8 -*-

my_unicode_string = u»Это юникод!»

В Python, начиная с версии 3, все строки являются юникодом.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!


Конкатенация строк

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

# -*- coding: utf-8 -*-

string_one = «Собака съела «
string_two = «мою книгу!»
string_three = string_one + string_two

print(string_three) # Собака съела мою книгу!



# -*- coding: utf-8 -*-

 

string_one = «Собака съела «

string_two = «мою книгу!»

string_three = string_one + string_two

 

print(string_three) # Собака съела мою книгу!

Оператор + конкатенирует две строки в одну

Методы строк

Строка является объектом в Python. Фактически, все, что есть в Python – является объектом. Если вы хотите узнать больше об Объектно-ориентированном программирование, мы рассмотрим это в другой статье «Классы в Python«. В данный момент достаточно знать, что строки содержат собственные встроенные методы. Например, допустим, у вас есть следующая строка:

my_string = «This is a string!»



my_string = «This is a string!»

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

Если вы открыли ваш интерпретатор, вы также можете сделать то же самое:

«This is a string!».upper()



«This is a string!».upper()

Существует великое множество других методов строк. Например, если вам нужно, что бы все было в нижнем регистре, вам нужно использовать метод lower(). Если вы хотите удалить все начальные и конечные пробелы, вам понадобится метод strip(). Для получения списка всех методов строк, впишите следующую команду в ваш интерпретатор:

Вы увидите что-то на подобие этого:

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’,
‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’,
‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’,
‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__-
setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’,
‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’,
‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’,
‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’,
‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’,
‘title’, ‘translate’, ‘upper’, ‘zfill’]



[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’,

‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’,

‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’,

‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__-

setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’,

‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’,

‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’,

‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’,

‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’,

‘title’, ‘translate’, ‘upper’, ‘zfill’]

Вы можете спокойно игнорировать методы, которые начинаются и заканчиваются двойным подчеркиванием, например __add__. Они не используются в ежедневном программировании в Python. Лучше обратите внимание на другие. Если вы хотите узнать, что делает тот или иной метод, просто обратитесь к справке. Например, если вы хотите узнать, зачем вам capitalize, впишите следующее, чтобы узнать:

help(my_string.capitalize)



help(my_string.capitalize)

Вы получите следующую информацию:

Help on built-in function capitalize:

capitalize(…)
S.capitalize() -> string

Выдача копии строки S только с заглавной буквой.



Help on built-in function capitalize:

 

capitalize(…)

    S.capitalize() -> string

 

Выдача копии строки S только с заглавной буквой.

Вы только что узнали кое-что о разделе, под названием интроспекция. Python может исследовать все свои объекты, что делает его очень легким в использовании. В основном, интроспекция позволяет вам спрашивать Python о нём. Вам моет быть интересно, как сказать о том, какой тип переменной был использован (другими словами int или string). Вы можете спросить об этом у Python!

type(my_string) # <type ‘str’>



type(my_string) # <type ‘str’>

Как вы видите, тип переменной my_string является str!

Нарезка строк

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

my_string = «I like Python!»



my_string = «I like Python!»

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

print( my_string[0:1] ) # I



print( my_string[0:1] ) # I

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

0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !



0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !

Таким образом, у нас есть строка длиной в 14 символов, начиная с нуля и до тринадцати. Давайте приведем несколько примеров, чтобы понять это лучше.

my_string[:1] # ‘I’
my_string[0:12] # ‘I like Pytho’
my_string[0:13] # ‘I like Python’
my_string[0:14] # ‘I like Python!’
my_string[0:-5] # ‘I like Py’
my_string[:] # ‘I like Python!’
my_string[2:] # ‘like Python!’



my_string[:1] # ‘I’

my_string[0:12] # ‘I like Pytho’

my_string[0:13] # ‘I like Python’

my_string[0:14] # ‘I like Python!’

my_string[0:-5] # ‘I like Py’

my_string[:] # ‘I like Python!’

my_string[2:] # ‘like Python!’

Как видно в данных примерах, мы можем назначить срез, лишь указав его начало (другими словами, my_string[2:]), конец среза (my_string[:1]), или оба (my_string[0:13]). Мы можем даже использовать отрицательные значения, которые начинаются с конца строки. Так что в примере, где мы указали my_string[0:-5], начало ведется с нуля и заканчивается 5 символами, перед концом строки. Вы можете задаться вопросом «Зачем мне это и где это можно применить?». Лично я использовал это для разбора записей с фиксированной шириной в файлах, или ситуативно для парсинга сложных названий файлов, с очень специфическими наименованиями. Также я использовал это для парсинга значений в бинарных файлах. Любая работа, которая включает в себя обработку текстовых файлов, может быть намного проще, если вы понимаете, как работает нарезка и как эффективно использовать данный инструмент. Вы также можете получить доступ к отдельным символам в строке с помощью индексации. Например:

Данный код выдаст первый символ в строке.

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

Форматирование строк (также известно как замещение) – это замещение значений в базовой строке. Большую часть времени вы будете вставлять строки внутри строк, однако, вам также понадобиться вставлять целые числа и числа с запятыми в строки весьма часто. Существует два способа достичь этой цели. Начнем с старого способа, после чего перейдем к новому:

# -*- coding: utf-8 -*-

my_string = «Я люблю %s» % «Python»
print(my_string) # Я люблю Python

var = «яблоки»
newString = «Я ем %s» % var
print(newString) # Я ем яблоки

another_string = «Я люблю %s и %s» % («Python», var)
print(another_string) # Я люблю Python и яблоки



# -*- coding: utf-8 -*-

 

my_string = «Я люблю %s» % «Python»

print(my_string) # Я люблю Python

 

var = «яблоки»

newString = «Я ем %s» % var

print(newString) # Я ем яблоки

 

another_string = «Я люблю %s и %s» % («Python», var)

print(another_string) # Я люблю Python и яблоки

Как вы могли догадаться, % — это очень важная часть вышеописанного кода. Этот символ указывает Python, что вы скоро вставите текст на его место. Если вы будете следовать за строкой со знаком процента и другой строкой или переменной, тогда Python попытается вставить ее в строку. Вы можете вставить несколько строк, добавив несколько знаков процента в свою строку. Это видно в последнем примере. Обратите внимание на то, что когда вы добавляете больше одной строки, вам нужно закрыть эти строки в круглые скобки. Теперь взглянем на то, что случится, если мы вставим недостаточное количество строк:

another_string = «Я люблю %s и %s» % «Python»

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: not enough arguments for format string



another_string = «Я люблю %s и %s» % «Python»

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: not enough arguments for format string

О-па. Мы не передали необходимое количество аргументов для форматирования строки. Если вы внимательно взгляните на пример, вы увидите, что у нас есть два экземпляра %, но для того, чтобы вставить строки, вам нужно передать столько же %, сколько у нас строк. Теперь вы готовы к тому, чтобы узнать больше о вставке целых чисел, и чисел с запятыми. Давайте взглянем.

my_string = «%i + %i = %i» % (1,2,3)
print(my_string) # ‘1 + 2 = 3’

float_string = «%f» % (1.23)
print(float_string) # ‘1.230000’

float_string2 = «%.2f» % (1.23)
print(float_string2) # ‘1.23’

float_string3 = «%.2f» % (1.237)
print(float_string3) # ‘1.24’



my_string = «%i + %i = %i» % (1,2,3)

print(my_string) # ‘1 + 2 = 3’

 

float_string = «%f» % (1.23)

print(float_string) # ‘1.230000’

 

float_string2 = «%.2f» % (1.23)

print(float_string2) # ‘1.23’

 

float_string3 = «%.2f» % (1.237)

print(float_string3) # ‘1.24’

Первый пример достаточно простой. Мы создали строку, которая принимает три аргумента, и мы передаем их. В случае, если вы еще не поняли, Python не делает никаких дополнений в первом примере. Во втором примере, мы передаем число с запятой. Обратите внимание на то, что результат включает множество дополнительных нулей (1.230000). Нам это не нужно, так что мы указываем Python ограничить выдачу до двух десятичных значений в третьем примере (“%.2f”). Последний пример показывает, что Python округлит числа для вас, если вы передадите ему дробь, что лучше, чем два десятичных значения. Давайте взглянем на то, что произойдет, если мы передадим неправильные данные:

int_float_err = «%i + %f» % («1», «2.00»)
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: %d format: a number is required, not str



int_float_err = «%i + %f» % («1», «2.00»)

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: %d format: a number is required, not str

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

int_float_err = «%i + %f» % (1, «2.00»)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: float argument required, not str



int_float_err = «%i + %f» % (1, «2.00»)

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: float argument required, not str

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

Шаблоны и новая методика форматирования строк

Этот метод был добавлен в Python 2.4 в виде шаблонов строк, но в качестве обычного метода string, работающего через метод format в версии 2.6. Так что это не самый свежий метод, просто обновленный. В любом случае, приступим к работе с шаблонами!

print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!



print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!

Должно быть это выглядит странно, но на самом деле мы сменили наши % на %(lang), с тем отличием, что данный объект идет в комплекте с переменной. Вторая часть пример вызывает словарь Python, который мы рассмотрим в следующей статье. В основном, это пара key:value, так что когда Python ищет ключ lang в строке и в указанном словаре ключей, он заменяет этот ключ его значением. Давайте взглянем на следующие примеры:

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



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

В первом примере вы могли заметить, что мы передали только одно значение, но оно было вставлено три раза. Это одно из преимуществ использования шаблонов. Второй пример был загвоздкой, в которой мы забыли передать ключ z. В третьем примере эта проблема была исправлена с соответствующим результатом. Теперь давайте взглянем на то, что мы можем сделать, по аналогии с методом форматирования строк:

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



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

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

Подведем итоги

Мы проработали большой объем в данной статье. Давайте разберемся:
Сначала мы узнали, как создавать строки, после чего мы перешли к вопросу об их конкатенации. После этого, мы взглянули на несколько методов, которые предлагает нам объект string. Далее, мы рассмотрели нарезку строк и закончили замещением строк.

индексирование, срезы, сортировка / Хабр

Данная статья является продолжением моей статьи «Python: коллекции, часть 1: классификация, общие подходы и методы, конвертация».

В данной статье мы продолжим изучать общие принципы работы со стандартными коллекциями (модуль collections в ней не рассматривается) Python.

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

ОГЛАВЛЕНИЕ:

  1. Индексирование
  2. Срезы
  3. Сортировка

1. Индексирование

1.1 Индексированные коллекции

Рассмотрим индексированные коллекции (их еще называют последовательности — sequences) — список (list), кортеж (tuple), строку (string).

Под индексированностью имеется ввиду, что элементы коллекции располагаются в определённом порядке, каждый элемент имеет свой индекс от 0 (то есть первый по счёту элемент имеет индекс не 1, а 0) до индекса на единицу меньшего длины коллекции (т.е. len(mycollection)-1).

1.2 Получение значения по индексу

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

При задании отрицательного индекса, последний элемент имеет индекс -1, предпоследний -2 и так далее до первого элемента индекс которого равен значению длины коллекции с отрицательным знаком, то есть (-len(mycollection).



элементы a b c d e
индексы 0 (-5) 1 (-4) 2 (-3) 3 (-2) 4 (-1)
	my_str = "abcde"
	print(my_str[0]) 		# a - первый элемент
	print(my_str[-1])		# e - последний элемент 
	print(my_str[len(my_str)-1]) 	# e - так тоже можно взять последний элемент
	print(my_str[-2]) 		# d - предпоследний элемент

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

my_2lvl_list = [[1, 2, 3], ['a', 'b', 'c']]
print(my_2lvl_list[0])      # [1, 2, 3] - первый элемент — первый вложенный список
print(my_2lvl_list[0][0])   # 1 — первый элемент первого вложенного списка
print(my_2lvl_list[1][-1])  # с — последний элемент второго вложенного списка

1.3 Изменение элемента списка по индексу

Поскольку кортежи и строки у нас неизменяемые коллекции, то по индексу мы можем только брать элементы, но не менять их:

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])	  # 1
my_tuple[0] = 100         # TypeError: 'tuple' object does not support item assignment

А вот для списка, если взятие элемента по индексу располагается в левой части выражения, а далее идёт оператор присваивания =, то мы задаём новое значение элементу с этим индексом.

my_list = [1, 2, 3, [4, 5]]
my_list[0] = 10
my_list[-1][0] = 40
print(my_list)      	# [10, 2, 3, [40, 5]]

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

my_list = [1, 2, 3, 4, 5]
my_list[5] = 6      # IndexError: list assignment index out of range

2 Срезы

2.1 Синтаксис среза

Очень часто, надо получить не один какой-то элемент, а некоторый их набор ограниченный определенными простыми правилами — например первые 5 или последние три, или каждый второй элемент — в таких задачах, вместо перебора в цикле намного удобнее использовать так называемый срез (slice, slicing).

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

Синтаксис среза похож на таковой для индексации, но в квадратных скобках вместо одного значения указывается 2-3 через двоеточие:

my_collection[start:stop:step]  # старт, стоп и шаг

Особенности среза:
Примеры срезов в виде таблицы:

Код примеров из таблицы

col = 'abcdefg'
print(col[:])       # abcdefg
print(col[::-1])    # gfedcba
print(col[::2])     # aceg
print(col[1::2])    # bdf
print(col[:1])      # a
print(col[-1:])     # g
print(col[3:4])     # d
print(col[-3:])     # efg
print(col[-3:1:-1]) # edc
print(col[2:5])     # cde

2.2. Именованные срезы

Чтобы избавится от «магических констант», особенно в случае, когда один и тот же срез надо применять многократно, можно задать константы с именованными срезами с пользованием специальной функции slice()()

Примечание: Nonе соответствует опущенному значению по-умолчанию. То есть [:2] становится slice(None, 2), а [1::2] становится slice(1, None, 2).

person = ('Alex', 'Smith', "May", 10, 1980)
NAME, BIRTHDAY = slice(None, 2), slice(2, None)       
	# задаем константам именованные срезы
        # данные константы в квадратных скобках заменятся соответствующими срезами
print(person[NAME])      # ('Alex', 'Smith')
print(person[BIRTHDAY])  # ('May', 10, 1980)
my_list = [1, 2, 3, 4, 5, 6, 7]
EVEN = slice(1, None, 2)
print(my_list[EVEN])     # [2, 4, 6]

2.3 Изменение списка срезом

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

Проиллюстрируем это на примерах ниже:

  • Даже если хотим добавить один элемент, необходимо передавать итерируемый объект, иначе будет ошибка TypeError: can only assign an iterable
    my_list = [1, 2, 3, 4, 5]
    # my_list[1:2] = 20     # TypeError: can only assign an iterable
    my_list[1:2] = [20]     # Вот теперь все работает
    print(my_list)          # [1, 20, 3, 4, 5]
    

  • Для вставки одиночных элементов можно использовать срез, код примеров есть ниже, но делать так не рекомендую, так как такой синтаксис хуже читать. Лучше использовать методы списка .append() и .insert():Срез аналоги .append() и insert()
    my_list = [1, 2, 3, 4, 5]
    my_list[5:] = [6]      # вставляем в конец — лучше использовать .append(6)
    print(my_list)         # [1, 2, 3, 4, 5, 6]
    my_list[0:0] = [0]     # вставляем в начало — лучше использовать .insert(0, 0)
    print(my_list)         # [0, 1, 2, 3, 4, 5, 6]
    my_list[3:3] = [25]    # вставляем между элементами — лучше использовать .insert(3, 25)
    print(my_list)         # [0, 1, 2, 25, 3, 4, 5, 6]
    

  • Можно менять части последовательности — это применение выглядит наиболее интересным, так как решает задачу просто и наглядно.
    my_list = [1, 2, 3, 4, 5]
    my_list[1:3] = [20, 30]
    print(my_list)          # [1, 20, 30, 4, 5]
    my_list[1:3] = [0]      # нет проблем заменить два элемента на один
    print(my_list)          # [1, 0, 4, 5]
    my_list[2:] = [40, 50, 60]   # или два элемента на три
    print(my_list)               # [1, 0, 40, 50, 60]
    

  • Можно просто удалить часть последовательности
    my_list = [1, 2, 3, 4, 5]
    my_list[:2] = []    # или del my_list[:2]
    print(my_list)      # [3, 4, 5]
    

2.4 Выход за границы индекса

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

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

my_list = [1, 2, 3, 4, 5]
print(my_list[-10])       # IndexError: list index out of range
print(my_list[10])        # IndexError: list index out of range

А в случае выхода границ среза за границы коллекции никакой ошибки не происходит:

my_list = [1, 2, 3, 4, 5]
print(my_list[0:10])      # [1, 2, 3, 4, 5] — отработали в пределах коллекции
print(my_list[10:100])	  # [] - таких элементов нет — вернули пустую коллекцию
print(my_list[10:11])     # [] - проверяем 1 отсутствующий элемент - пустая коллекция, без ошибки

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

3 Сортировка элементов коллекции

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

3.1 Функция sorted()

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

  • функция не меняет исходную коллекцию, а возвращает новый список из ее элементов;
  • не зависимо от типа исходной коллекции, вернётся список (list) ее элементов;
  • поскольку она не меняет исходную коллекцию, ее можно применять к неизменяемым коллекциям;
  • Поскольку при сортировке возвращаемых элементов нам не важно, был ли у элемента некий индекс в исходной коллекции, можно применять к неиндексированным коллекциям;
  • Имеет дополнительные не обязательные аргументы:
    reverse=True — сортировка в обратном порядке
    key=funcname (начиная с Python 2.4) — сортировка с помощью специальной функции funcname, она может быть как стандартной функцией Python, так и специально написанной вами для данной задачи функцией и лямбдой.
my_list = [2, 5, 1, 7, 3]
my_list_sorted = sorted(my_list)
print(my_list_sorted)       # [1, 2, 3, 5, 7]

my_set = {2, 5, 1, 7, 3}
my_set_sorted = sorted(my_set, reverse=True)
print(my_set_sorted)        # [7, 5, 3, 2, 1]

Пример сортировки списка строк по длине len() каждого элемента:

my_files = ['somecat.jpg', 'pc.png', 'apple.bmp', 'mydog.gif']
my_files_sorted = sorted(my_files, key=len)
print(my_files_sorted)      # ['pc.png', 'apple.bmp', 'mydog.gif', 'somecat.jpg']

3.2 Функция reversed()

Функция reversed() применяется для последовательностей и работает по другому:

  • возвращает генератор списка, а не сам список;
  • если нужно получить не генератор, а готовый список, результат можно обернуть в list() или же вместо reversed() воспользоваться срезом [: :-1];
  • она не сортирует элементы, а возвращает их в обратном порядке, то есть читает с конца списка;
  • из предыдущего пункта понятно, что если у нас коллекция неиндексированная — мы не можем вывести её элементы в обратном порядке и эта функция к таким коллекциям не применима — получим «TypeError: argument to reversed() must be a sequence»;
  • не позволяет использовать дополнительные аргументы — будет ошибка «TypeError: reversed() does not take keyword arguments».
my_list = [2, 5, 1, 7, 3]
my_list_sorted = reversed(my_list)
print(my_list_sorted)           # <listreverseiterator object at 0x7f8982121450>
print(list(my_list_sorted))     # [3, 7, 1, 5, 2]
print(my_list[::-1])            # [3, 7, 1, 5, 2] - тот же результат с помощью среза

3.3 Методы списка .sort() и .reverse()

У списка (и только у него) есть особые методы .sort() и .reverse() которые делают тоже самое, что соответствующие функции sorted() и reversed(), но при этом:

  • Меняют сам исходный список, а не генерируют новый;
  • Возвращают None, а не новый список;
  • поддерживают те же дополнительные аргументы;
  • в них не надо передавать сам список первым параметром, более того, если это сделать — будет ошибка — не верное количество аргументов.
my_list = [2, 5, 1, 7, 3]
my_list.sort()
print(my_list)          # [1, 2, 3, 5, 7]

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

my_list = [2, 5, 1, 7, 3]
my_list = my_list.sort()
print(my_list)          # None

3.4 Особенности сортировки словаря

В сортировке словаря есть свои особенности, вызванные тем, что элемент словаря — это пара ключ: значение.

UPD: Так же, не забываем, что говоря о сортировке словаря, мы имеем ввиду сортировку полученных из словаря данных для вывода или сохранения в индексированную коллекцию. Сохранить данные сортированными в самом стандартном словаре не получится, они в нем, как и других неиндексированных коллекциях находятся в произвольном порядке.

  • sorted(my_dict) — когда мы передаем в функцию сортировки словарь без вызова его дополнительных методов — идёт перебор только ключей, сортированный список ключей нам и возвращается;
  • sorted(my_dict.keys()) — тот же результат, что в предыдущем примере, но прописанный более явно;
  • sorted(my_dict.items()) — возвращается сортированный список кортежей (ключ, значение), сортированных по ключу;
  • sorted(my_dict.values()) — возвращается сортированный список значений
my_dict = {'a': 1, 'c': 3, 'e': 5, 'f': 6, 'b': 2, 'd': 4}
mysorted = sorted(my_dict)
print(mysorted)           # ['a', 'b', 'c', 'd', 'e', 'f']
mysorted = sorted(my_dict.items())
print(mysorted)           # [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6)]
mysorted = sorted(my_dict.values())
print(mysorted)           # [1, 2, 3, 4, 5, 6]

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

Для решения этой задачи можно в качестве специальной функции сортировки передавать lambda-функцию lambda x: x[1] которая из получаемых на каждом этапе кортежей (ключ, значение) будет брать для сортировки второй элемент кортежа.

population = {"Shanghai": 24256800, "Karachi": 23500000, "Beijing": 21516000, "Delhi": 16787941}
# отсортируем по возрастанию населения:
population_sorted = sorted(population.items(), key=lambda x: x[1])
print(population_sorted)
# [('Delhi', 16787941), ('Beijing', 21516000), ('Karachi', 23500000), ('Shanghai', 24256800)]

UPD от ShashkovS: 3.5 Дополнительная информация по использованию параметра key при сортировке

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

shop = [('каретка', 1200), ('шатун', 1000), ('седло', 300),
        ('педаль', 100), ('седло', 1500), ('рама', 12000),
        ('обод', 2000), ('шатун', 200), ('седло', 2700)]

def prepare_item(item):
    return (item[0], -item[1])

shop.sort(key=prepare_item)

Результат сортировки

for det, price in shop:
    print('{:<10} цена: {:>5}р.'.format(det, price))

# каретка    цена:  1200р.
# обод       цена:  2000р.
# педаль     цена:   100р.
# рама       цена: 12000р.
# седло      цена:  2700р.
# седло      цена:  1500р.
# седло      цена:   300р.
# шатун      цена:  1000р.
# шатун      цена:   200р.

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

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

# Данные скопировать из примера выше
shop.sort(key=lambda x: (x[0], -x[1]))

Дополнительные детали и примеры использования параметра key:

UPD от ShashkovS: 3.6 Устойчивость сортировки

Допустим данные нужно отсортировать сначала по столбцу А по возрастанию, затем по столбцу B по убыванию, и наконец по столбцу C снова по возрастанию.

Если данные в столбце B числовые, то при помощи подходящей функции в key можно поменять знак у элементов B, что приведёт к необходимому результату.

А если все данные текстовые? Тут есть такая возможность.

Дело в том, что сортировка sort в Python устойчивая (начиная с Python 2.2), то есть она не меняет порядок «одинаковых» элементов.

Поэтому можно просто отсортировать три раза по разным ключам:

data.sort(key=lambda x: x['C'])
data.sort(key=lambda x: x['B'], reverse=True)
data.sort(key=lambda x: x['А'])

Дополнительная информация по устойчивости сортировки и примеры: wiki.python.org/moin/HowTo/Sorting#Sort_Stability_and_Complex_Sorts (на наглийском).

Приглашаю к обсуждению:

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

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

Доступ к символам в строках основан на операции индексирования – после строки или имени переменной, ссылающейся на строку, в квадратных скобках указываются номера позиций необходимых символов.

Так же следует понимать, что этот самый доступ, основан на смещении, т.е. расстоянии символов от левого или правого края строки. Данное расстояние измеряется целыми числами и по сути определяет номер позиции символов в строке – их индекс. Подвох заключается в словосочетании «измеряется целыми числами«, а это означает, что индекс может быть как положительным так и отрицательным: положительные индексы – это отсчет от левого края, а отрицательные – от правого. Причем отсчет символов от левого края начинается с \(0\), а с правого начинается с \(-1\) (минус единицы).

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

>>> 'string'[0]
's'
>>> 
>>> 'string'[5]
'g'
>>> 
>>> 
>>> s = 'STRING'
>>> 
>>> s[0]
'S'
>>> 
>>> s[5]
'G'

Так же мы можем извлеч срез – последовательность символов внутри исходной строки, которую еще иногда называют подстрокой:

>>> s = 'AAA***BBB^^^'
>>> 
>>> s[0:3]
'AAA'
>>> 
>>> s[3:6]
'***'
>>> 
>>> s[9:12]
'^^^'

А еще мы можем извлекать символы из строки или среза с указанным шагом:

>>> s = 'a0-b1-c2-d3-e4-f5-g6'
>>> 
>>> s[::3]
'abcdefg' 
>>> 
>>> s[1::3]
'0123456' 
>>> 
>>> s[2::3]
'------'
>>> 
>>> 
>>> s[3:12:3]
'bcd'
>>> s[9:1:-3]
'dcb'

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


Извлечение символов — S[i]

Извлечение одного символа из строки – это, действительно, самый простой случай. Давайте снова рассмотрим строку:

>>> s = 'STRING'

Что бы извлеч символы ‘S‘, ‘R‘ и ‘G‘ мы можем выполнить следующие простые операции:

>>> s[0], s[2], s[5]
('S', 'R', 'G')

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

>>> s[-6], s[-4], s[-1]
('S', 'R', 'G')

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

>>> s[4], s[-2]
('N', 'N')
>>> 
>>> s[len(s) - 2], s[4 - len(s)]
('N', 'N')

Визуально отображение индексов на символы строки выглядит вот так:

Если указать индекс, который выходит за пределы строки, то это приведет к ошибке:

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

Отсутствие индекса, так же считается ошибкой.


Извлечение срезов — S[i:j]

Извлечение срезов строк выполняется по двум индексам, которые разделяются двоеточием:

>>> s = '*a*bb*ccc*dddd*'
>>> 
>>> s[1:2]
'a'
>>> 
>>> s[3:5]
'bb'
>>> 
>>> s[6:9]
'ccc'
>>> 
>>> s[10:14]
'dddd'

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

Тех же результатов можно добиться если указывать отрицательные индексы:

>>> s[-14:-13], s[-12:-10], s[-9:-6], s[-5:-1]
('a', 'bb', 'ccc', 'dddd')

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

>>> s[5:1]
''
>>> s[-10:-14]
''

И даже, если индексы окажутся равны, мы все равно увидим пустую строку вместо сообщения об ошибке:

>>> s[1:1]
''
>>> s[-14:-14]
''

Появится ли сообщение об ошибке если не указать индексы вообще? Нет, вместо этого мы увидим всю строку целиком:

>>> s[:]
'*a*bb*ccc*dddd*'

Такое поведение связано с тем, что индексы начала и конца среза имеют значения по умолчанию: начало – всегда \(0\), конец – всегда len(s). Так что команда s[:] является эквивалентной команде s[0:len(s)]. Наличие таких предустановленных значений является весьма удобным, если мы хотим извлекать срезы от начала строки до указанного символа, или от некоторого символа до конца строки:

>>> s = '*a*bb*ccc*dddd*'
>>> 
>>> s[:2]    #  эквивалентно s[:-13]
'*a'
>>> 
>>> s[:5]    #  эквивалентно s[:-10]
'*a*bb'
>>> 
>>> s[:-1]    #  эквивалентно s[:14]
'*a*bb*ccc*dddd'
>>> 
>>> s[-3:]    #  эквивалентно s[12:]
'dd*'
>>> 
>>> s[-10:]    #  эквивалентно s[5:]
'*ccc*dddd*'

Снова, обратите внимание на то, что если срез извлекается от начала строки до указанного символа, то сам указанный символ в разрез не включается. А если срез извлекается от указанного символа до конца строки, то этот символ будет включен в начало среза. Такое поведение гарантирует что конкатенация двух таких срезов будет равна исходной строке:

>>> s = 'xxxxYYYY'
>>> 
>>> s[:4] + s[4:]
'xxxxYYYY'
>>> 
>>> s[:-3] + s[-3:]
'xxxxYYYY'

Операция извлечения среза допускает указание индексов, выходящих за пределы строки:

>>> s = '*a*bb*ccc*dddd*'
>>> 
>>> s[:100]
'*a*bb*ccc*dddd*'
>>> 
>>> s[6:100]
'ccc*dddd*'
>>> 
>>> s[100:]
''

Извлечение срезов с заданным шагом — S[i:j:k]

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

>>> s = 'A1-B2-C3-D4-E5-'
>>> 
>>> s[3:12:3]
'BCD'
>>> 
>>> s[:9:2]
'A-2C-'
>>> 
>>> s[3::4]
'B3-'
>>> 
>>> s[::6]
'ACE'

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

>>> s[-12:-3:3], s[:-6:2], s[-12::4]
('BCD', 'A-2C-', 'B3-')

Визуально все это можно представить вот так:

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

Величина шага имеет значение по умолчанию, равное \(1\) – это соответствует извлечению всех элементов подряд. А учитывая, что начало среза и его конец так же имеют установленные по умолчанию значения, равные \(0\) и len(s), то мы можем вообще ничего не указывать (кроме двух двоеточий, разумеется):

>>> s = 'A1-B2-C3-D4-E5-'
>>> 
>>> s[::]
'A1-B2-C3-D4-E5-'

Может ли значение шага быть отрицательным? Да:

>>> 'ABCDEFG'[::-1]
'GFEDCBA'
>>> 
>>> 'ABCDEFG'[::-2]
'GECA'

По сути, знак указанного числа в шаге указывает направление в котором выполняется извлечение символов из среза. Значение \(-1\) означает, что нужно извлеч каждый последующий символ, двигаясь от правого края к левому. А значение \(-2\) — извлеч каждый второй символ, так же двигаясь от конца к началу строки.

Давайте выполним несколько примеров и посмотрим, как это можно наглядно представить:

>>> s = 'ABCDEFGHIJKLMNO'
>>> 
>>> s[::2]
'ACEGIKMO'
>>> 
>>> s[::-2]
'OMKIGECA'
>>> 
>>> s[::4]
'AEIM'
>>> 
>>> s[::-4]
'OKGC'

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

>>> s = 'ABCDEFGHIJKLMNO'
>>> 
>>> s[10:4]    #  по умолчанию шаг равен 1
''

Глядя на пустую строку, котору вернул интерпретатор и картинку становится понятно, что что-то не так. Мы ясно видим, что извлечение начинается с индекса под номером \(10\), т.е. с символа «K» и даже несмотря на то, что извлечение происходит слева направо (так как по умолчанию шаг равен \(1\)), символ «K» просто обязан попасть в результирующую строку. Но его там нет!!!

Настало время осознать, что индексы символов в строке и их смещения – это не одно и то же. Работая с последовательностями нам проще всего воспринимать индексы символов (номера их позиций) чем их смещений. Я даже уверен что после того как вы разберетесь со смещениями, вы все равно будете представлять себе индексы.


Индексы и смещения символов

Что ж давайте сделаем небольшое отступление и попробуем разобраться. Вот уже знакомая нам строка:

>>> s = 'STRING'

А вот так мы отображаем индексы на символы:

Почему мы так делаем? Потому что это удобнее чем смещения:

Говоря о смещениях, мы подразумеваем левую границу символов (левую сторону квадратов в которых они изображены на рисунках). Так, например, смещение символа «S» относительно левого края строки равно \(0\) т.е. он вообще не смещен, поэтому операция s[0] его и возвращает. А смещение символа «G» относительно правого края равно \(-1\), поэтому операция s[-1] возвращает «G«. На этом же принципе основаны и все другие операции индексирования, будь-то срезы или срезы с заданным шагом.

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

Теперь, когда мы знаем, что такое смещения, нам гораздо проще понять почему операция s[4:2:1] возвращает пустую строку вместо символа «I«:

Глядя на эту картинку, нам начинает казаться, что символ «I» с индексом \(4\) должен попасть в результирующую строку. Но интерпретатор Python ориентируется не по индексам, а смещениям и с его точки зрения все выглядит вот так:

Так как символ «I» располагается перед смещением с номером \(4\), а отсчет ведется именно от смещений, то и в результирующей строке его быть не должно.

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

>>> s[2:6]    #  эквивалентно s[2:]
'RING'

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

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

Скорее всего, у вас возник вопрос по поводу того как работает операция s[::-1], ведь ее левый индекс по умолчанию равен \(0\), а правый – len(s), но даже не смотря на то, что извлечение символов должно выполняться справа налево, т.е. мы, по идее, должны увидеть пустую строку, мы видим, как все прекрасно работает:

>>> s = 'STRING'
>>> 
>>> s[::-1]
'GNIRTS'
>>> 
>>> s[::-2]
'GIT'

Такое исключение из правил, создано намеренно, а именно – для удобства. Потому что это, действительно, удобнее чем каждый раз писать, что-то вроде s[len(s):0:-1] или s[len(s):0:-2].


Отрицательное значение шага

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

>>> s = 'ABCDEFGHIJKLMNO'
>>> 
>>> s[11:2:-2]
'LJHFD'
>>> 
>>> s[:4:-3]
'OLIF'
>>> 
>>> s[10::-4]
'KGC'
>>> 
>>> s[-3:-6:-7]
'M'

Помните мы задавались вопросом о том, как работает операция s[::-1]? И был дан расплывчато-туманный ответ, что это яко бы просто техническая особенность, созданная для удобства. Так вот это действительно технически реализованный трюк, который заключается в том, установленные по умолчанию значения начала и конца среза (начало – \(0\), конец – len(s)) меняются местами, если величина шага имеет отрицательное значение:

>>> s[::2], s[0:len(s):2]
('ACEGIKMO', 'ACEGIKMO')
>>> 
>>> s = 'ABCDEFGHIJKLMNO'
>>> s[::-2], s[-1:-len(s)-1:-2]
('OMKIGECA', 'OMKIGECA')

Возможно вы немного удивились, ожидая вместо команды s[-1:-len(s)-1:-2] увидеть команду s[len(s):0:-2]. Но если вспомнить, что символы извлекаются не по индексам, а по смещениям, так же вспомнив, что извлечение среза выполняется от первого указанного смещения до второго, то станет ясно, что команда s[len(s):0:-2] выдаст не то, что нужно:

>>> s[len(s):0:-2], s[::-2], s[-1:-len(s)-1:-2]
('OMKIGEC', 'OMKIGECA', 'OMKIGECA')

В заключение, хочется напомнить о двух простых правилах из Дзена Python:

  • Простое лучше чем сложное;
  • Сложное лучше чем запутанное.

Почему именно эти правила. Потому что вам может захотеться использовать в своем коде какие-то, так сказать, хитро-выдуманные трюки с индексированием. С одной стороны: «Почему бы и нет??? Ведь программирование – это еще и способ самовыражения!». Но с другой стороны – это еще замечательный способ вынести мозг и себе, и что хуже всего, другим людям. Так что, если вдруг, вы придумаете, каой-нибудь фокус с индексированием строк, то не поленитесь раскрыть его секрет в комментариях к коду.

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

>>> sym = 'ABCDEFGHIJ'
>>> num = '1234567890'
>>> i = 2
>>> 
>>> sym[int(num[i])-len(sym):int(num[len(sym)-i])-i:int(num[i])]
'DG'

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

Как нарезать строки в Python?

Введение

В этом руководстве мы узнаем, как можно нарезать строки в Python.

Python поддерживает нарезку строк. Это создание новой подстроки из данной строки на основе определяемых пользователем начального и конечного индексов.

Способы нарезки строк в Python

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

res_s = s [start_pos: end_pos: step]
 

Здесь,

  • res_s хранит возвращенную подстроку,
  • s — заданная строка,
  • start_pos — начальный индекс, из которого нам нужно разрезать строку s,
  • end_pos — конечный индекс, перед на котором завершится операция нарезки,
  • этап — это шаги, которые будет выполнять процесс нарезки от start_pos до end_pos.

Примечание : Все три вышеупомянутых параметра являются необязательными. По умолчанию для start_pos установлено значение 0 , end_pos считается равным длине строки, а шаг step установлен на 1 .

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

Строки среза в Python — Примеры

Нарезать строки Python можно разными способами.

Обычно мы получаем доступ к строковым элементам (символам), используя простую индексацию, которая начинается с 0 до n-1 (n — длина строки). Следовательно, для доступа к 1st элемент строки string1 мы можем просто использовать приведенный ниже код.

s1 = String1 [0]
 

Опять же, есть другой способ доступа к этим символам, то есть использование отрицательной индексации . Отрицательная индексация начинается с -1 до -n (n — длина данной строки).Обратите внимание, что отрицательная индексация выполняется с другого конца строки. Следовательно, чтобы на этот раз получить доступ к первому символу, нам нужно следовать приведенному ниже коду.

s1 = Строка 1 [-n]
 

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

1. Разрезать строки в Python с началом и концом

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

# нарезка строки с двумя параметрами
s = "Привет, мир!"

res1 = s [2: 8]
res2 = s [-4: -1] # использование отрицательной индексации

print ("Результат1 =", res1)
print ("Результат2 =", res2)
 

Выход :

Результат1 = llo Wo
Результат2 = rld
 

Здесь,

  • Мы инициализируем строку s как «Hello World!» ,
  • Сначала мы разрезаем данную строку с начальным индексом 2 и конечным индексом 8 .Это означает, что результирующая подстрока будет содержать символы от с [2] до с [8-1] ,
  • Точно так же для следующей подстроки результирующая подстрока должна содержать символы из с [ -4] от до с [(- 1) -1] .

Значит, наш вывод оправдан.

2. Разрезать строки, используя только начало или конец

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

# нарезка строки с одним параметром
s1 = "Чарли"
s2 = "Иордания"

res1 = s1 [2:] # значение по умолчанию конечной позиции устанавливается равным длине строки
res2 = s2 [: 4] # значение по умолчанию для начальной позиции установлено на 0

print ("Результат1 =", res1)
print ("Результат2 =", res2)
 

Выход :

Result1 = arlie
Результат2 = Йорд
 

Здесь,

  • Сначала мы инициализируем две строки, s1 и s2 ,
  • Для нарезки обеих мы просто упоминаем start_pos для s1 и end_pos только для s2,
  • Следовательно, для res1 это содержит подстроку s1 от индекса 2 (как упоминалось) до последнего (по умолчанию он установлен в n-1).В то время как для res2 диапазон индексов лежит от 0 до 4 (указано).

3. Разрезать строки в Python с параметром шага

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

# нарезка строки с параметром шага
s = "Python"
s1 = "Котлин"

res = s [0: 5: 2]
res1 = s1 [-1: -4: -2] # использование отрицательных параметров

print ("Результирующая нарезанная строка =", res)
print ("Результирующая нарезанная строка (отрицательные параметры) =", res1)
 

Выход :

Результирующая нарезанная строка = Pto
Результирующая нарезанная строка (отрицательные параметры) = nl
 

В приведенном выше коде

  • Мы инициализируем две строки s и s1 и пытаемся разрезать их для заданных начальных и конечных индексов, как мы это делали для нашего первого примера,
  • Но на этот раз мы упомянули значение шага , которое было установлено равным 1 по умолчанию для предыдущих примеров,
  • Для res размер шага 2 означает, что при переходе для получения подстроки с индекса 0 до 4 каждый раз индекс будет увеличиваться на значение 2.То есть первый символ — s [0] (‘P’), следующие символы в подстроке будут s [0 + 2] и s [2 + 2] , пока индекс просто меньше 5.
  • Для следующего, то есть res1 , упомянутый шаг равен (-2). Следовательно, как и в предыдущем случае, символы в подстроке будут иметь вид s1 [-1] , затем s1 [(- 1) + (- 2)] или s1 [-3] , пока индекс не станет чуть меньше (-4).

4. Обращение строки с использованием нарезки в Python

Используя нарезку строки отрицательного индекса в Python, мы также можем перевернуть строку и сохранить ее в другой переменной.Для этого нам просто нужно упомянуть шаг размером (-1) .

Давайте посмотрим, как это работает, на примере, приведенном ниже.

# изменение направления строки с помощью нарезки строки
s = "AskPython"
rev_s = s [:: - 1] # обратная строка, сохраненная в rev_s

печать (rev_s)
 

Выход :

nohtyPksA
 

Как мы видим, строка s перевернута и сохранена в rev_s . Примечание : и в этом случае исходная строка остается нетронутой.

Заключение

Итак, в этом руководстве мы узнали о методологии нарезки строк и ее различных формах. Надеюсь, читатели получили четкое представление о теме.

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

Список литературы

.

Строка фрагмента Python — JournalDev

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

Строка фрагмента Python

Синтаксис строки фрагмента Python:

 
str_object [start_pos: end_pos: step]
  

Нарезка начинается с индекса start_pos (включен) и заканчивается индексом end_pos (исключая). Параметр step используется для указания шагов от начала до конца индекса.

Python Разделение строк всегда следует этому правилу: s [: i] + s [i:] == s для любого индекса «i».

Все эти параметры являются необязательными — значение по умолчанию start_pos равно 0, значение по умолчанию end_pos — длина строки, а значение шага по умолчанию — 1.

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

 
s = 'HelloWorld'

печать (s [:])

печать (s [::])
  

Выход:

 
Привет мир
Привет мир
  

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

Давайте рассмотрим еще несколько примеров разрезания строки.

 
s = 'HelloWorld'
first_five_chars = s [: 5]
печать (first_five_chars)

third_to_fifth_chars = s [2: 5]
печать (third_to_fifth_chars)
  

Выход:

 
Здравствуйте
лло
  

Обратите внимание, что значение индекса начинается с 0, поэтому start_pos 2 относится к третьему символу в строке.

Перевернуть строку с помощью нарезки

Мы можем перевернуть строку с помощью нарезки, указав значение шага как -1.

 
s = 'HelloWorld'
reverse_str = s [:: - 1]
печать (reverse_str)
  

Вывод: dlroWolleH

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

 
s1 = s [2: 8: 2]
печать (s1)
  

Вывод: loo

Здесь подстрока содержит символы из индексов 2,4 и 6.

 
s1 = s [8: 1: -1]
печать (s1)
  

Вывод: lroWoll

Здесь значения индекса берутся от конца до начала.Подстрока состоит из индексов с 1 по 7 от конца до начала.

 
s1 = s [8: 1: -2]
печать (s1)
  

Вывод: lool

Срез Python также работает с отрицательными индексами, в этом случае start_pos исключается, а end_pos включается в подстроку.

 
s1 = s [-4: -2]
печать (s1)
  

Вывод: или

Нарезка строк Python изящно обрабатывает индексы вне диапазона.

 
>>> s = 'Python'
>>> s [100:]
''
>>> с [2:50]
'тон'
  

Это все, что касается функции фрагмента строки Python для создания подстроки.

Вы можете получить полный скрипт Python и другие примеры Python в нашем репозитории GitHub. .

индексов среза строки Python — от среза до конца строки

Переполнение стека

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

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

  3. Вакансии
    Программирование и связанные с ним технические возможности карьерного роста

  4. Талант
    Нанимайте технических специалистов и создавайте свой бренд работодателя

  5. Реклама
    Обратитесь к разработчикам и технологам со всего мира

  6. О компании

.

Python — интерполяция строк с кусочками кортежа?

Переполнение стека

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

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

  3. Вакансии
    Программирование и связанные с ним технические возможности карьерного роста

  4. Талант
    Нанимайте технических специалистов и создавайте свой бренд работодателя

  5. Реклама
    Обратитесь к разработчикам и технологам со всего мира

  6. О компании

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *