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

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

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

В данном примере мы передали две строки вместо целого числа и дроби. Это привело к ошибке 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

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

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

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

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

В первом примере вы могли заметить, что мы передали только одно значение, но оно было вставлено три раза. Это одно из преимуществ использования шаблонов. Второй пример был загвоздкой, в которой мы забыли передать ключ 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

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

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

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

python-scripts.com

Строки. Функции и методы строк — Документация Python Summary 1

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

ps.readthedocs.io

Основы Python — кратко. Строки. / Habr

Для начала маленькое замечание.

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

# -*- coding: cp1251 -*-

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

Строки

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

>>> "habrahabr"
'habrahabr'
>>> 'foo bar boz'
'foo bar boz'
>>> "won't"
"won't"
>>> 'don"t'
'don"t'
>>> "couldn\"t"
'couldn"t'
>>> """multi line
... very long
... string constant"""
'multi line\nvery long\nstring constant'
>>> 'this takes \
... two lines'
'this takes two lines'

>>> "Hello "+"word"
'Hello word'
>>> "Hello "*3
'Hello Hello Hello '

>>> str = "Hello, cruel world!"
# получить 4 символ строки
>>> str[3] 
'l'
# все символы с 8 по 14
>>> str[7:14]
'cruel w'
# каждый второй символ со 2 по 13
>>> str[1:12:2]
'el,cul'
# некоторые значения можно опускать
# каждый второй символ строки.
>>> str[::2]
'Hlo re ol!'

# первые 2 символа строки
>>> str[:2]
'He'
# вся строка кроме 2 первых символов
>>> str[2:]
'llo, cruel world!'

Также срезы могут принимать отрицательные значения.

# последний символ
>>> str[-1]
'!' 
# второй символ с конца
>>> str[-2]
'd'
# два последних символа
>>> str[-2:]
'd!'
# все символы кроме последних двух
>>> str[:-2]
'Hello, cruel worl'

Для определения длины строки используется функция len().

Unicode

В последних версиях Пайтон очень хорошо поддерживается работа с Unicode-строками.

Для задания unicode-строки в виде константы используется префикс u.

>>> uni = u"Тест"
>>> uni
u'\u0422\u0435\u0441\u0442'

>>> uni = unicode("Тест", "UTF-8")
>>> uni
u'\u0422\u0435\u0441\u0442'

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

>>> uni.encode("UTF-8")
'\xd0\xa2\xd0\xb5\xd1\x81\xd1\x82'
>>> uni.encode("CP1251")
'\xd2\xe5\xf1\xf2'

>>> str = "Mary has a little lamb"
>>> str.split(" ")
['Mary', 'has', 'a', 'little', 'lamb']
>>> for word in str.split(" "):
...     print word
...
Mary
has
a
little
lamb

Домашнее задание.

1. Написать программу, выводящую заданную пользователем строку как минимум в 3 разных кодировках. При этом писать вызов метода encode() в программе можно только 1 раз.
2. Написать программу поиска самого длинного слова в строке, разделенной пробелами.
3. (Повышенная сложность) Написать программу декодирования телефонного номера для АОН.
По запросу АОНа АТС посылает телефонный номер, используя следующие правила:
— Если цифра повторяется менее 2 раз, то это помеха и она должна быть отброшена
— Каждая значащая цифра повторяется минимум 2 раза
— Если в номере идут несколько цифр подряд, то для обозначения «такая же цифра как предыдущая» используется идущий 2 или более подряд раз знак #

Например, входящая строка 4434###552222311333661 соответствует номеру 4452136
Кстати, регулярные выражения использовать в этих заданиях — нельзя 🙂

habr.com

Программирование на Python. Часть 2: Строки в питоне

Программирование на Python. Часть 2

Сергей Яковлев
Опубликовано 02.08.2010

Серия контента:

Этот контент является частью # из серии # статей: Программирование на Python. Часть 2

https://www.ibm.com/developerworks/ru/library/?series_title_by=**auto**

Следите за выходом новых статей этой серии.

Этот контент является частью серии:Программирование на Python. Часть 2

Следите за выходом новых статей этой серии.

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

1. Строковый тип.
2. Срезы (slicing).
3. Операции со строками.
4. Unicode.
5. Форматирование.
6. Встроенные методы.
7. Тест на конкатенацию.

1. Строковый тип

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

>>> word = 'strength'
>>> word[2] = 'y'  
TypeError: 'str' object does not support item assignment

Но если очень хочется, то изменить можно, например, так:

>>> word = word[:3] + '!' + word[4:]
'str!ngth'

Или так:

>>> word = word.replace('!','e')
'strength'

Индексы могут иметь отрицательные значения для отсчета с конца – отсчет начинается с -1:

>>> word[-1]     
h

Строки в питоне можно заключать как в одинарные, так и в двойные кавычки, причем кавычки одного типа могут быть произвольно вложены в кавычки другого типа:

>>> '123'
'123'
>>> "7'8''9"
"7'8''9"

Длинные строки можно разбивать на несколько строк с помощью обратного слеша:

>>> s = 'this is first word\
and this is second word'

Большие наборы строк и целые тексты можно заключать в тройные кавычки:

>>> print """
One
Two
Three
"""

Обратный слеш в строках используется для так называемой escape-последовательности.

После слеша может идти один или несколько символов.

В следующем примере комбинация ‘\n‘ – это новая строка, ‘\t‘ – это табуляция:

>>> s ='a\nb\tc'
>>> print s
a
b	c

В следующем примере строка состоит из бинарной последовательности трех чисел – двух восьмеричных и одного шестнадцатеричного:

>>> s = '\001\002\x03'
>>> s
'\x01\x02\x03'
>>> len(s)
3

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

2. Срезы

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

>>> word = 'strength'
>>> word[4]
n
>>> word[0:2]
st
>>> word[2:4]
re

Если в срезе опущен первый символ, значит, он равен нулю; если опущен последний символ – он равен длине строки:

>>> word[:3]
str
>>> word[5:]
gth

Можно выбирать последовательность символов из строки с определенной цикличностью:

>>> s = '1234567890'
>>> s[::2]
'13579'
>>> s[1:10:2]
'13579'
>>> s[::-1]
'0987654321'

3. Операции со строками

Строки можно склеивать с помощью оператора + :

>>> var = 'Moscow' + 'city'

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

Строки можно умножать с помощью оператора * :

>>> '123' * 3
'123123123'

Строки можно сравнивать с помощью операторов <, <=, ==, !=, >, >=.

4. Unicode

Unicode позволяет применять все символы, используемые в текстах на разных языках. Ранее мы могли использовать только 256 символов из определенной кодовой страницы. Перед строкой нужно поставить спецификатор u – при этом на каждый символ отводится 2 байта, так как по умолчанию ставится кодировка UTF-8:

>>> w = u'Вася Пупкин'
>>> w
u'\u0412\u0430\u0441\u044f \u041f\u0443\u043f\u043a\u0438\u043d'

Юникодную строку можно также создать в известной кодировке: ASCII, UTF-8, UTF-16, KOI8-R, CP1251, CP866 и т.д.:

>>> s = unicode("Привет", "KOI8-R")
>>> s
u'\u043f\xf7\u044f\u2500\u043f\u2566\u043f\u2561\u043f\u2563\u044f\u250c'

Метод encode() позволяет преобразовывать строки Unicode в обычные строки, содержащие текст в указанной кодировке:

>>> s.encode("KOI8-R")
'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82'

5. Форматирование

Форматирование в питоне – мощный инструмент управления строками. Есть несколько подходов – стандартный и с использованием шаблонов. Для форматирования в питоновских строках используется стандартный оператор – символ %. Слева от процента указываем строку, справа – значение или список значений:

>>> s = 'Hello %s' % 'word'
>>> s
'Hello word'

>>> s = 'one  %s %s' % ('two','three')
>>> s
'one  two three'

Если нужно преобразование числа в строку, используется числовой спецификатор – %d или %f:

>>> s = 'one  %d %f' % (2 , 3.5)
>>> s
'one  2 3.500000'

При форматировании можно указать общую ширину строки и точность для чисел, при этом число будет дополнено незначащими нулями. В следующем примере результирующая строка будет иметь длину 10 символов, на дробную часть будет отведено 5 символов:

>>> x = 4/3
>>> '%10.5f' % x
'   1.00000'

Пробелы слева можно отформатировать нулями:

>>> from math import pi
>>> '%015.10f' % pi
'0003.1415926536'

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

>>> from string import Template
>>> s = Template('1 $two 3 4 $five')
>>> d={}
>>> d['two']=2
>>> d['five']=5
>>> s.substitute(d)
'1 2 3 4 5'

Таблица типов форматирования для строк

6. Методы

Строки обладают большим набором разнообразных методов. Наиболее популярные из них:

find – находит подстроку в строке – возвращает позицию вхождения строки, либо -1:

>>> s = 'The find method finds a substring'
>>> s.find('find')
4
>>> s.find('finds')
16
>>> s.find('findsa')
-1

join – объединяет через разделитель набор строк:

>>> seq = ['one','two','three']
>>> sep = ','
>>> sep.join(seq)
'one,two,three'

split – это обратная функция для join, разбивает строку на последовательность:

>>> s = '/usr/local/bin'
>>> s.split('/')
['', 'usr', 'local', 'bin']

replace – заменяет в строке одну подстроку на другую:

>>> s = 'replace method returns a string'
>>> s.replace('returns','return')
'replace method return a string'

strip – удаляет пробелы слева и справа:

>>> '       this is whitespace string    '.strip()
'this is whitespace string'

translate – в отличие от replace, может делать множественную замену. В следующем примере каждый символ ‘1‘ в исходной строке будет заменен на символ ‘3‘, а символ ‘2‘ – на символ ‘4‘ соответственно:

>>> from string import maketrans
>>> table = maketrans('12', '34')
>>> '1212 5656'.translate(table)
'3434 5656'

Для конверсии различных типов в строковый используются функции str, int, ord, chr:

• str – конвертирует число в строку;
• int – конвертирует строку в число;
• ord – возвращает значение байта;
• chr – конвертирует число в символ.

Таблица методов, доступных в Python 3.0

7. Тест на конкатенацию

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

Проведем несложный тест: к строке будем конкатенировать символьное представление натуральных чисел по возрастанию в диапазоне от 0 до миллиона.

1-й метод. Используем для хранения строки массив символов array. Будем просто добавлять туда строковое представление натурального числа, а в конце применим метод array.tostring(). Этот метод оказался самым медленным.

2-й метод. Используем тот же алгоритм, что и в первом методе, только вместо массива array используем список, а в конце сделаем стандартный джойн.

3-й метод. Используем модуль cStringIO, в котором есть возможность писать в псевдо-файл, который на самом деле хранится в памяти. В конце вызываем метод getvalue().

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

Код:

import time

loop_count = 1000000

def method1():
  from array import array
  char_array = array('c') 
  for num in xrange(loop_count):
    char_array.fromstring(`num`)
  return char_array.tostring()
    
def method2():
  str_list = []
  for num in xrange(loop_count):
    str_list.append(`num`)
  return ''.join(str_list)
    
def method3():
  from cStringIO import StringIO
  file_str = StringIO()
  for num in xrange(loop_count):
    file_str.write(`num`)
  return file_str.getvalue()    
  
def method4():
  return ''.join([`num` for num in xrange(loop_count)])
    
t1 = time.time()
method1()
t2 = time.time()
print "\t%.1f" % ((t2 - t1))
method2()
t3 = time.time()
print "\t%.1f" % ((t3 - t2))
method3()
t4 = time.time()
print "\t%.1f" % ((t4 - t3))
method4()
t5 = time.time()
print "\t%.1f" % ((t5 - t4))

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

Строки относятся к наиболее популярным базовым типам. Срезы, большой набор встроенных функций, удобное форматирование позволяет гибко и оперативно производить манипуляции там, где мы могли бы затратить значительно большее количество времени на рутинные операции, будь это какой-то другой язык. Питон — это удобство, простота, минимальное количество усилий. В продолжение цикла речь пойдет о списках и словарях. Затем поговорим о модулях, классах и работе с файловой системой средствами Python. Код примеров проверялся на версии питона 2.6.

Ресурсы для скачивания

Подпишите меня на уведомления к комментариям

www.ibm.com

Интерактивный учебник языка Python

1. Строки

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

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

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

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

What is the answer?
42

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 = 'Hello', то S[0] == 'H', S[1] == 'e', S[2] == 'l', S[3] == 'l', S[4] == 'o'.

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

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

Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1. То есть S[-1] == 'o', S[-2] == 'l', S[-3] == 'l', S[-4] == 'e', S[-5] == 'H'.

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

Если же номер символа в срезе строки 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], то третий пар

pythontutor.ru