Строки в питоне 3: работа со строками, форматирование,методы split, strip

 var1 = 'Привет мир!'
var2 = "программирование на Python"

Доступ к значениям в строках

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

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

#!/usr/bin/python3

var1 = 'Привет мир!'
var2 = "программирование на Python"

print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

Когда код выполниться, он покажет следующий результат:

var1[0]:  П
var2[1:5]:  ytho

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

Вы можете «обновить» существующую строку c присваиванием переменной на другую строку. Новое значение может быть связано с его предыдущим значением или совершенно другой строкой. Например:

#!/usr/bin/python3

var1 = 'Привет мир!'

print ("Обновление строки :- ", var1[:6] + 'Python')

Когда код выполниться, получиться следующий результат:

Обновление строки :-  Hello Python

Символ Escape

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

Символ escape интерпретируется: в одинарных кавычках, а также в двойных кавычках.

Специальные строковые операторы

Предположим, переменная строка а, имеет «Hello» а переменная b равна «Python», тогда:

Оператор форматирования строки

Одна из самых привлекательных особенностей языка Python является оператор форматирования строк %. Этот оператор является уникальным для строк и блоков, имеющие функции из языка C printf(). Ниже приведен простой пример:

#!/usr/bin/python3

print ("Меня зовут %s и мой вес равен %d кг!" % ('AndreyEx', 71))

Когда код выполниться, будет показан следующий результат:

Меня зовут AndreyEx и мой вес равен 71 кг!

Вот полный набор списка символов, которые могут быть использованы вместе с %:

Другие поддерживаемые символы и функции перечислены в следующей таблице:

Тройные кавычки

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

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

#!/usr/bin/python3

para_str = """это длинная строка, которая состоит из
несколько строк и непечатаемых символов, таких как
TAB ( \t ) и они показывают тот путь, когда отображается.
Символы новой строки в строке, прямо как
в скобках [ \n ], или просто новую строку с
присваиванием переменной также будет отображаться.
"""
print (para_str)

Когда приведенный выше код выполнится, он произведет следующий результат. Обратите внимание, что каждый специальный символ был преобразован в печатный вид, вплоть до последней новой строки в конце строки между «вверх». и закрытие тройные кавычки. Также отметим, что новая строка происходит либо с явным возвратом каретки в конце строки либо escape кодом (\n):

это длинная строка, которая состоит из
несколько строк и непечатаемых символов, таких как
TAB (    ) и они показывают тот путь, когда отображается.
Символы новой строки в строке, прямо как
в скобках [
 ], или просто новую строку с
присваиванием переменной также будет отображаться.

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

#!/usr/bin/python3

print ('C:\\nowhere')

Когда код выполниться, он выдаст следующий результат:

C:\nowhere

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

#!/usr/bin/python3

print (r'C:\\nowhere')

Когда код выполниться, он выдаст следующий результат:

C:\\nowhere

Строки Юникода

В Python 3 все строки представлены в Unicode. В Python 2 хранятся в виде 8-битного ASCII, следовательно, требуется указать «u», чтобы сделать его Unicode. Больше нет необходимости в настоящее время.

Встроенные методы строк

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Введение в функции Python 3 для работы со строками

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

В этом руководстве мы рассмотрим несколько строковых функций в Python 3.

Функции str.upper() и str.lower() возвращают строку со всеми буквами исходной строки, преобразованными в прописные или строчные буквы. Символы в строке, которые не являются буквами, меняться не будут.

Преобразуем строку Sammy Shark в верхний регистр:

ss = "Sammy Shark"
print(ss.upper())

Вывод:

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

Вывод:

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

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

Существует ряд строковых методов, которые возвращают логические значения:

Рассмотрим несколько методов в действии:

number = "5"
letters = "abcdef"

print(number.isnumeric())
print(letters.isnumeric())
Вывод:
True
False

Метод str.isnumeric() возвращает для строки number = «5» значение True, а тот же метод для строки letters = «abcdef» возвращает значение False.

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

Создадим несколько строк:

movie = "2001: A SAMMY ODYSSEY"
book = "A Thousand Splendid Sharks"
poem = "sammy lived in a pretty how town"

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

print(movie.islower())
print(movie.isupper())
print(book.istitle())
print(book.isupper())
print(poem.istitle())
print(poem.islower())

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

Вывод для строки movie:

Вывод для строки book:

Вывод для строки poem:

Проверка регистра строки позволяет правильно отсортировать данные. Логические методы также полезны для валидации полей форм на сайте.

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

Чтобы продемонстрировать этот метод в действии, найдем длину предложения:

open_source = "Sammy contributes to open source."
print(len(open_source))

Вывод:

Мы инициализируем переменную open_source строковым значением «Sammy contributes to open source.». Затем передаем эту переменную в метод len() с помощью len(open_source). После этого используем  print() для вывода результата на экран.

Помните, что любой символ, заключенный в одинарные или двойные кавычки, будет учитываться методом len().

Метод str.join() объединяет две строки и разделяет их указанным символом.

Давайте создадим строку:

balloon = "Sammy has a balloon."

Теперь воспользуемся методом str.join(), чтобы добавить пробел к этой строке. Мы можем сделать так:

Если мы выведем это:

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

Вывод:

S a m m y   h a s   a   b a l l o o n .

Мы также можем использовать метод str.join() для возврата строки, которая является перевернутой исходной строкой:

print("".join(reversed(balloon)))

Вывод:

Метод str.join() также полезен для объединения списка строк в новую единственную строку.

Создадим разделенную запятыми строку из списка строк:

print(",".join(["sharks", "crustaceans", "plankton"]))

Вывод:

sharks,crustaceans,plankton

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

".join(["sharks", "crustaceans", "plankton"]).

Также можно и разбивать строки. Для этого используется метод str.split():

Вывод:

['Sammy', 'has', 'a', 'balloon.']

Метод str.split() возвращает список строк, разделенных пробелами, если никакой другой параметр не задан.

Также можно использовать str.split() для удаления определенных частей строки. Например, давайте удалим из строки букву a:

print(balloon.split("a"))

Вывод:

['S', 'mmy h', 's ', ' b', 'lloon.']

Теперь буква a удалена, и строки разделены там, где она располагалась.

Метод str.replace() применять для замены части строки. Допустим, что  шарик, который был у Сэмми, потерян. Поскольку у Сэмми больше нет этого шарика, изменим подстроку «has» на новую строку «had»:

print(balloon.replace("has","had"))

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

Вывод:

Методы str.join(), str.split() и str.replace() позволяют более эффективно управлять строками в Python.

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

Данная публикация представляет собой перевод статьи «An Introduction to String Functions in Python 3» , подготовленной дружной командой проекта Интернет-технологии.ру

Python 3 #8: методы строк

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

строка.имя_метода(аргументы)

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

и мы собираемся для нее вызвать метод

String.upper()

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

Вот по такому синтаксису вызываются различные методы строк. Причем, сама переменная string продолжает ссылается на ту же самую неизмененную строку «Hello World!». Как мы с вами говорили на предыдущем занятии, строки – это неизменяемые объекты, поэтому метод upper возвращает новую строку с заглавными буквами, не меняя прежней.

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

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

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

Так тоже можно делать.

Ну и раз уж мы затронули метод upper, который переводит буквы в верхний регистр, то отметим противоположный ему метод:

String.lower()

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

возвращает строку «hello world!». Соответственно, сама строка здесь остается прежней, измененным является новый строковый объект, который и возвращает метод lower. По такому принципу работают все методы при изменении строк. Следующий метод

String.count(sub[, start[, end]])

возвращает число повторений подстроки sub в строке String. Два необязательных аргумента:

• start – индекс, с которого начинается поиск;
• end – индекс, которым заканчивается поиск.

В самом простом случае, мы можем для строки

определить число повторений сочетаний «ra»:

получим значение 2 – именно столько данная подстрока встречается в нашей строке.

Теперь предположим, что мы хотим начинать поиск с буквы k, имеющей индекс 4.

Тогда метод следует записать со значением start=4:

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

и получаем значение 0. Почему? Ведь на индексах 9 и 10 как раз идет подстрока «ra»? Но здесь, также как и в срезах, последний индекс исключается из рассмотрения. То есть, мы говорим, что нужно дойти до 10-го, не включая его. А вот если запишем 11:

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

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

String.find(sub[, start[, end]])

возвращает индекс первого найденного вхождения подстроки sub в строке String. А аргументы start и end работают также как и в методе count. Например:

вернет 1, т.к. первое вхождение «br» как раз начинается с индекса 1. Поставим теперь значение start=2:

и поиск начнется уже со второго индекса. Получим значение 8 – индекс следующего вхождения подстроки «br». Если мы укажем подстроку, которой нет в нашей строке:

то метод find возвращает -1. Третий аргумент end определяет индекс до которого осуществляется поиск и работает также как и в методе count.

Метод find ищет первое вхождение слева-направо. Если требуется делать поиск в обратном направлении: справа-налево, то для этого используется метод

String.rfind(sub[, start[, end]])

который во всем остальном работает аналогично find. Например:

возвратит 8 – первое вхождение справа.

Наконец, третий метод, аналогичный find – это:

String.index(sub[, start[, end]])

Он работает абсолютно также как find, но с одним отличием: если указанная подстрока sub не находится в строке String, то метод приводит к ошибке:

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

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

String.replace(old, new, count=-1)

Выполняет замену подстрок old на строку new и возвращает измененную строку. Например, в нашей строке, мы можем заменить все буквы a на o:

на выходе получим строку «obrokodobro». Или, так:

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

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

Заменит только первые две буквы a: «msg.replace(«a», ‘o’, 2)». При значении -1 количество замен неограниченно.

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

String.isalpha()

возвращает True, если строка целиком состоит из букв и False в противном случае. Посмотрим как он работает:

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

мы получим False, т.к. имеется символ пробела.

Похожий метод

String.isdigit()

возвращает True, если строка целиком состоит из цифр и False в противном случае. Например:

т.к. имеется символ точки, а вот так:

получим значение True. Такая проверка полезна, например, перед преобразованием строки в целое число:

dig = input("Введите число: ")
if(dig.isdigit()):
   dig = int(dig)
    print(dig)
else:
   print("Число введено неверно")

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

String.rjust(width[, fillchar = ‘ ‘])

возвращает новую строку с заданным числом символов width и при необходимости слева добавляет символы fillchar:

Получаем строку «  abc» с двумя добавленными слева пробелами. А сама исходная строка как бы прижимается к правому краю. Или, можно сделать так:

Получим строку «—abc». Причем вторым аргументом можно писать только один символ. Если записать несколько, то возникнет ошибка:

Если ширина width будет меньше длины строки:

то ничего не изменится. Аналогично работает метод

String.ljust(width[, fillchar = ‘ ‘])

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

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

String.split(sep=None, maxsplit=-1)

возвращает коллекцию строк, на которые разбивается исходная строка String. Разбивка осуществляется по указанному сепаратору sep. Например:

"Иванов Иван Иванович".split(" ")

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

"Иванов Иван Иванович".split()

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

digs = "1, 2,3, 4,5,6"
digs.replace(" ", "").split(",")

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

Обратный метод

String.join(список)

возвращает строку из объединенных элементов списка, между которыми будет разделитель String. Например:

d = digs.replace(" ", "").split(",")
", ".join(d)

получаем строку «1, 2, 3, 4, 5, 6». Или так, изначально была строка:

fio = "Иванов Иван Иванович"

и мы хотим здесь вместо пробелов поставить запятые:

fio2 = ",".join(fio.split())

Теперь fio2 ссылается на строку с запятыми «Иванов,Иван,Иванович».

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

String.strip()

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

"   hello world         \n".strip()

возвращает строку «hello world». Аналогичные методы:

String.rtrip() и String.ltrip()

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

Вот такие методы строк существуют в Python. Для наглядности ниже они представлены в таблице:

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

1. Написать программу корректности ввода телефонного номера по шаблону:

x(xxx)xxxxxx

где x – любая цифра от 0 до 9. Данные представлены в виде строки.

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

«2+3+6.7 + 82 + 5.7 +1″

на строку, в которой все «+» заменены на «-» и удалены все пробелы

3. Написать программу вывода чисел 0; -100; 5.6; -3 в виде столбца:

	0
	-100
	5.6
	-3

в котором все строки выровнены по правому краю (подсказка: воспользуйтесь методом rjust).

4. В строке «abrakadabra» найдите все индексы подстроки «ra» и выведите их (индексы) в консоль.

Строки в Python. Создание, объединение, повторение.

Введение

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

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

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

Создание строк и вывод их на экран

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

'Это строка заключена в одинарные кавычки'

"Это строка заключена в двойные кавычки"

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

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

print("Давайте выведем на экран эту строку!")

Давайте выведем на экран эту строку!

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

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

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

Давайте соединим строки "Sammy" и "Shark" вместе с помощью функции print():

 print("Sammy" + "Shark")

SammyShark

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

print("Sammy" + 27)

TypeError: Can't convert 'int' object to str implicitly

Если бы мы захотели создать строку "Sammy27", мы могли бы это сделать поставив число 27 в кавычки "27", таким образом превратив его из целого числа в строку. Преобразование числа в строку может быть полезным, когда мы, например, имеем дело с индексами или телефонными номерами. Например, когда нам нужно объединить телефонный код страны и телефонный номер, но при этом мы не хотим их складывать .

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

Как работает конкатенация строк в Python 3? Примеры.

Повторение строк

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

Давайте выведем на экран "Sammy" 9 раз с помощью оператора *.

print("Sammy" * 9)

SammySammySammySammySammySammySammySammySammy

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

Сохранение строк в качестве значения для переменных

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

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

my_str = "Sammy likes declaring strings."

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

print(my_str)

И получим следующий вывод:

Sammy likes declaring strings.

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

Заключение

Итак, в этом руководстве мы рассмотрели основы работы со строковыми данными в Python 3. А именно, научились создавать и выводить на экран строки, объединять их и повторять, а также сохранять строки в переменных. Но все это конечно же является лишь самыми начальными знаниями о возможностях использования строк в Python 3.

Интерактивный учебник языка 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:]. Аналогично если оп

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

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

Начиная с 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
Кстати, регулярные выражения использовать в этих заданиях — нельзя 🙂

  >>> name = "Эрик"
>>> "Привет,% s." % название
«Привет, Эрик.»
  

  >>> name = "Эрик"
>>> возраст = 74
>>> "Здравствуйте,% s. Вы% s." % (Назовите возраст)
«Привет, Эрик. Вам 74 года.
  

  >>> first_name = "Эрик"
>>> last_name = "Idle"