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

Строка считывается со стандартного ввода функцией input() . Напомним, что для двух строк определена операция сложения (конкатенации), также определена операция умножения строки на число.

Строка состоит из последовательности символов. Узнать количество символов (длину строки) можно при помощи функции len .

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

На самом деле каждая строка, с точки зрения Питона, — это объект класса str. Чтобы получить по объекту другой объект другого класса, как-то ему соответствующий, можно использовать функцию приведения. Имя этой функции совпадает с именем класса, к которому мы приводим объект. (Для знатоков: эта функция — это конструктор объектов данного класса.) Пример: int — класс для целых чисел. Перевод строки в число осуществляется функцией int() .

s = input() print(len(s)) t = input() number = int(t) u = str(number) print(s * 3) print(s + ' ' + u)

2. Срезы (slices)

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента подстроки или подпоследовательности.

Есть три формы срезов. Самая простая форма среза: взятие одного символа строки, а именно, S[i] — это срез, состоящий из одного символа, который имеет номер i . При этом считается, что нумерация начинается с числа 0. То есть если , то , , , , .

Заметим, что в Питоне нет отдельного типа для символов строки. Каждый объект, который получается в результате среза S[i] — это тоже строка типа str.

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

Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1 . То есть , , , , .

Или в виде таблицы:

Строка S	H	e	l	l	o
Индекс	S[0]	S[1]	S[2]	S[3]	S[4]
Индекс	S[-5]	S[-4]	S[-3]	S[-2]	S[-1]

Если же номер символа в срезе строки S больше либо равен len(S) , или меньше, чем -len(S) , то при обращении к этому символу строки произойдет ошибка IndexError: string index out of range .

Срез с двумя параметрами: S[a:b] возвращает подстроку из b — a символов, начиная с символа c индексом a , то есть до символа с индексом b , не включая его. Например, S[1:4] == ‘ell’ , то же самое получится если написать S[-4:-1] . Можно использовать как положительные, так и отрицательные индексы в одном срезе, например, S[1:-1] — это строка без первого и последнего символа (срез начинается с символа с индексом 1 и заканчиватеся индексом -1, не включая его).

При использовании такой формы среза ошибки IndexError никогда не возникает. Например, срез S[1:5] вернет строку ‘ello’ , таким же будет результат, если сделать второй индекс очень большим, например, S[1:100] (если в строке не более 100 символов).

Если опустить второй параметр (но поставить двоеточие), то срез берется до конца строки. Например, чтобы удалить из строки первый символ (его индекс равен 0), можно взять срез S[1:] . Аналогично если опустить первый параметр, то можно взять срез от начала строки. То есть удалить из строки последний символ можно при помощи среза S[:-1] . Срез S[:] совпадает с самой строкой S .

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

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

Если задать срез с тремя параметрами S[a:b:d] , то третий параметр задает шаг, как в случае с функцией range , то есть будут взяты символы с индексами a , , и т. д. При задании значения третьего параметра, равному 2, в срез попадет кажый второй символ, а если взять значение среза, равное -1 , то символы будут идти в обратном порядке. Например, можно перевернуть строку срезом S[::-1] .

s = 'abcdefg' print(s[1]) print(s[-1]) print(s[1:3]) print(s[1:-1]) print(s[:3]) print(s[2:]) print(s[:-1]) print(s[::2]) print(s[1::2]) print(s[::-1])

Источник

Как получить последние символы строки в Python

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

В Python строка – это последовательность символов, и каждый символ в ней имеет связанный с ним индексный номер. Например, у нас есть строковая переменная sample_str , которая содержит строку:

sample_str = "Sample String"

Каждый символ в этой строке имеет порядковый номер, а начинается нумерация (индексация) с 0. То есть:

‘S’ имеет индекс 0
‘a’ имеет индекс 1
‘m’ имеет индекс 2
‘p’ имеет индекс 3
‘l’ имеет индекс 4
‘e’ имеет индекс 5
‘ ‘ имеет индекс 6
‘S’ имеет индекс 7
‘t’ имеет индекс 8
‘r’ имеет индекс 9
‘i’ имеет индекс 10
‘n’ имеет индекс 11
‘g’ имеет индекс 12

String в Python предоставляет оператор [] для доступа к любому символу в строке по индексу. Нам нужно передать позицию индекса в квадратных скобках, и оператор вернет символ с этим индексом. Например, sample_str[i] вернет символ в i-й позиции.

Примечание редакции: о том, как найти сам индекс, читайте в статье “Как найти индекс символа в строке в Python”.

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

Получение последнего символа строки при помощи отрицательной индексации

Помимо положительных индексов, мы можем передавать в оператор [] и отрицательные. Каждый символ в строке имеет отрицательный индекс, связанный с ним. Последний символ строки имеет индекс -1, предпоследний – -2 и так далее.

Таким образом, если наша строка – ‘Sample String’, то отрицательная индексация в ней будет выглядеть следующим образом:

‘S’ имеет индекс -13
‘a’ имеет индекс -12
‘m’ имеет индекс -11
‘p’ имеет индекс -10
‘l’ имеет индекс -9
‘e’ имеет индекс -8
‘ ‘ имеет индекс -7
‘S’ имеет индекс -6
‘t’ имеет индекс -5
‘r’ имеет индекс -4
‘i’ имеет индекс -3
‘n’ имеет индекс -2
‘g’ имеет индекс -1

Последний символ строки имеет индексную позицию -1. Поэтому, чтобы получить последний символ из строки, передайте -1 в квадратных скобках. Пример:

sample_str = "Sample String" # Получить последний символ строки, т.е. символ с индексом -1 last_char = sample_str[-1] print('Last character: ', last_char) # Вывод: # Last character: g

Получение последнего символа строки с помощью функции len()

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

sample_str = "Sample String" # Получить длину строки length = len(sample_str) # Получить последний символ, т.е. символ с индексом length - 1 last_char = sample_str[length - 1] print('Last character: ', last_char) # Вывод: # Last character: g

Мы получили последний символ, но это решение немного сложнее предыдущего.

До сих пор мы извлекали один символ, но что, если нам нужно больше? Например, если мы хотим получить последние 2, 3, 4 и т.д. символов строки. По сути, нам нужен доступ к подстроке заданной длины из конца строки. Как это сделать?

Извлекаем несколько последних символов строки

В Python оператор [] может принимать не только отдельный индекс, но и диапазон индексов. При этом возвращается фрагмент строки, т.е. подстрока.

start – индекс, с которого начнется выборка символов, по умолчанию значение равно 0.
end – индекс, до которого будет производиться выборка символов из строки, значение по умолчанию – конец строки. Сам конечный индекс в выборку не входит.
step – шаг, значение по умолчанию – 1.

Чтобы получить последние N символов строки, нужно либо передать отрицательные индексы, либо использовать функцию len() для вычисления диапазона.

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

sample_str = "Sample String" # Получить последние 3 символа last_chars = sample_str[-3:] print('Last 3 character: ', last_chars) # Вывод: # Last 3 character: ing

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

Получаем последние символы строки с помощью функции len()

sample_str = "Sample String" # Получить длину строки length = len(sample_str) # Получить 3 последних символа last_chars = sample_str[length - 3 :] print('Last 3 character: ', last_chars) # Вывод: # Last 3 character: ing

Сначала мы вычислили длину строки, а затем сделали срез от индексной позиции length — 4 до конца строки. Так мы получили подстроку, содержащую последние три символа исходной строки.

Источник

Срезы строк [ Python 3 ]

Иногда нужно бывает работать с целыми частями строки, в таком случае мы используем срезы (slices). Срезы похожи на комбинацию индексации и функции range() .

Рассмотрим строку s = ‘abcdefghij’ .

Положительные индексы	0	1	2	3	4	5	6	7	8	9
Строка	a	b	c	d	e	f	g	h	i	j
Отрицательные индексы	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1

С помощью среза мы можем получить несколько символов исходной строки, создав диапазон индексов разделенных двоеточием s[x:y] .

Следующий программный код:

print(s[2:5]) print(s[0:6]) print(s[2:7])

При построении среза s[x:y] первое число – это то место, где начинается срез (включительно), а второе – это место, где заканчивается срез (невключительно). Разрезая строки, мы создаем подстроку, которая по сути является строкой внутри другой строки.

Срез до конца, от начала

Если опустить второй параметр в срезе s[x:] (но поставить двоеточие), то срез берется до конца строки. Аналогично если опустить первый параметр s[:y] , то можно взять срез от начала строки. Срез s[:] совпадает с самой строкой s .

Следующий программный код:

Срез s[:] возвращает исходную строку.

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

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

Следующий программный код:

Удалить из строки последний символ можно при помощи среза s[:-1] .

Шаг среза

Мы можем передать в срез третий необязательный параметр, который отвечает за шаг среза. К примеру, срез s[1:7:2] создаст строку bdf состоящую из каждого второго символа (индексы 1, 3, 5 , правая граница не включена в срез).

Отрицательный шаг среза

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

Следующий программный код:

print(s[1:7:2]) print(s[3::2]) print(s[:7:3]) print(s[::2]) print(s[::-1]) print(s[::-2])

bdf dfhj adg acegi jihgfedcba jhfdb

Подводя итог

s = ‘abcdefghij’

Программный код	Результат	Пояснение
s[2:5]	cde	строка состоящая из символов с индексами 2, 3, 4
s[:5]	abcde	первые пять символов строки
s[5:]	fghij	строка состоящая из символов с индексами от 5 до конца
s[-2:]	ij	последние два символа строки
s[:]	abcdefghij	вся строка целиком
s[1:7:2]	bdf	строка состоящая из каждого второго символа с индексами от 1 до 6
s[::-1]	jihgfedcba	строка в обратном порядке, так как шаг отрицательный

Изменение символа строки по индексу

Предположим, у нас есть строка s = ‘abcdefghij’ и мы хотим заменить символ с индексом 4 на ‘X’ . Можно попытаться написать код:

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

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

Мы создаем два среза: от начала строки до 3 символа и с 5 символа по конец строки, а между ними вставляем нужный нам символ, который встанет на 4 позицию.

Примечания

Примечание 1. Синтаксис срезов строк очень похож на синтаксис функции range() .

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

Источник