Строки. Функции и методы строк — Документация 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=" ")
Python 3 — Строки | ИТ Блог. Администрирование серверов на основе Linux (Ubuntu, Debian, CentOS, openSUSE)
Строки являются одними из самых популярных типов в Python. Мы можем создать их, просто заключив символы в кавычках. Python рассматривает одиночные кавычки так же, как и двойные кавычки. Создание строк так же просто, как и присвоение значения переменной. Например:
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 интерпретируется: в одинарных кавычках, а также в двойных кавычках.

ПредставлениеШестнадцатеричный символОписание
\a0x07Звонок или оповещение
\b0x08Backspace
\cxControl-х
\C-xControl-х
\e0x1bEscape
\f0x0CFormfeed
\M- \C-xMeta-Control-x
\n0x0a
Новая линия
\nnnВосьмеричная запись, где п находится в диапазоне от 0,7
\r0x0dВозврат каретки
\s0x20Пробел
\t0x09Табуляция
\v0x0BВертикальная табуляция
\xСимвол х
\xnnШестнадцатеричное, где n находится в диапазоне от 0,9, a.f, или A.F

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

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

операторОписаниепример
+Конкатенация – Добавляет значения по обе стороны от оператораA + B = HelloPython
*Повторение – Создает новые строки, объединяя нескольких копий одной и той же строкиа * 2 = HelloHello
[]Кусочек – Выдает символ из данного индексаа [1] = е
[ : ]Диапазон среза – Дает символы из заданного диапазонаа [1: 4] = ELL
inВозвращает истину, если символ существует в данной строкеН = 1
not inВозвращает истину, если символ не существует в данной строкеМ <> 1
r/RRaw String – Подавляет фактическое значение символов Escape. Синтаксис для необработанных строк точно такой же, как и для обычных строк, за исключением raw строки оператора, буква «r», которая предшествует кавычки. «R» может быть в нижнем регистре (r) или в верхнем регистре (R) и должна быть размещена непосредственно предшествующей первой кавычки.print r’\n’ печатает \n и print R’\n’печатает \n
%Формат – Выполняет форматирование строкСм в следующем разделе

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

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

#!/usr/bin/python3

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

 

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

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

 

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

S.No.Формат символов и преобразование
1%c символ
2%s преобразование строки с помощью str() до форматирования
3%i десятичное число
4%d десятичное число
5%u беззнаковое десятичное целое
6%o восьмеричное целое
7%x шестнадцатеричное число (прописные буквы)
8%X шестнадцатеричное число (заглавные буквы)
9%e экспоненциальное (с строчной «х»)
10%E экспоненциальное (с «E» в верхнем регистре)
11%f вещественное число с плавающей точкой
12%g наименьшее из %f и %е
13%G наименьшее из% F% и E

 

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

S.No.Символ и функциональность
1*           
аргумент определяет ширину или точность
2–           выравнивание по левому краю
3+          отобразить знак
4<sp>  поставить пробел перед положительным числом
5#         добавить восьмеричной ведущий ноль ( «0») или шестнадцатеричным ведущий «0x» или «0X», в зависимости от того, был использован «х» или «X».
60         заместить слева нулями (вместо пробелов)
7«%%» оставляет вас с одним буквальным «%»
8(var) соотнесение переменных (словарные аргументы)
9m.n.  минимальная общая ширина и n число цифр, отображаемых после десятичной точки (если заявл.)

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

Тройные кавычки в 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 включает в себя следующие встроенные методы манипулирования строками:

S.No.Методы и описание
1capitalize() – Прописная первая буква строки
2center(width, fillchar) – Возвращает строку, заполненную с FillChar от исходной строки с центром в общем столбце width.
3count(str, beg = 0,end = len(string)) – Считает, сколько раз str имеет вхождение в строке или в подстроках строки, начиная с индекса str и заканчивается индексом end.
4decode(encoding = ‘UTF-8’,errors = ‘strict’) – Декодирует строку, используя кодек, зарегистрированный для кодирования. кодирования по умолчанию строки по умолчанию кодировке.
5encode(encoding = ‘UTF-8’,errors = ‘strict’) – Возвращает закодированные строки версии строки; при ошибке, по умолчанию вызывает исключение ValueError, если ошибки не указываются с  ‘ignore’ or ‘replace’.
6endswith(suffix, beg = 0, end = len(string)) – Определяет, является ли строка или подстроку строки (если начальный индекс нач и заканчивая концом индекса приведены) заканчивается суффиксом; возвращает истину, если так и ложь в противном случае.
7expandtabs(tabsize = 8) – Расширяет вкладки в строке на несколько пробелов; по умолчанию 8 пространств на вкладке, если TabSize не предусмотрено.
8find(str, beg = 0 end = len(string)) – Определить, встречается ли строка в строке или в подстроки строки, если начинается с индекса beg и заканчивается индексом end, индекс возвращается, если найден и -1 в противном случае.
9index(str, beg = 0, end = len(string)) – То же действие, что find(), но вызывает исключение, если строка не найдена.
10isalnum() – Возвращает истину, если строка имеет по крайней мере 1 символ и все символы являются алфавитно-цифровыми и ложью в противном случае.
11isalpha() – Возвращает истину, если строка имеет по крайней мере 1 символ и все символы буквенные и ложь в противном случае.
12isdigit() – Возвращает истину, если строка содержит только цифры и ложь в противном случае.
13islower() – Возвращает истину, если строка имеет по крайней мере 1 символ в нижнем регистре и все символы в нижнем регистре и ложь в противном случае.
14isnumeric() – Возвращает истину, если строка Юникода содержит только числовые символы и ложь в противном случае.
15isspace() – Возвращает истину, если строка содержит только символы пробелов и ложь в противном случае.
16istitle() – Возвращает истину, если строка имеет«titlecased» и ложь в противном случае.
17isupper() – Возвращает истину, если строка имеет по крайней мере один символ в верхнем регистре или все символы в верхнем регистре и ложь в противном случае.
18join(seq) – Слияния (Объединяет) строковых элементов в последовательности seq в строку со строкой разделителя.
19len(string) – Возвращает длину строки
20ljust(width[, fillchar]) – Возвращает space-padded строку в исходную строку с выравниванием влево на итоговую ширину столбцов.
21lower() – Преобразует все прописные буквы в строке в нижний регистр.
22lstrip() – Удаляет начальные пробелы в строке.
23maketrans() – Возвращает таблицу перевода для использования в функции перевода.
24max(str) – Возвращает максимальный алфавитный символ из строки str.
25min(str) – Возвращает минимальный алфавитный символ из строки str.
26replace(old, new [, max]) – Заменяет все вхождения old в строке на new или в большинстве случаев, если max задано.
27rfind(str, beg = 0,end = len(string)) – То же, что find(), но поиск в обратном направлении в строке.
28rindex( str, beg = 0, end = len(string)) – То же, что index(), но поиск в обратном направлении в строке.
29rjust(width,[, fillchar]) – Возвращает space-padded строку из исходной строки, выравнивается по правому краю в количестве width столбцов.
30rstrip() – Удаляет все конечные пробелы из строки.
31split(str=””, num=string.count(str)) – Разделяет строку в соответствии с разделителем str (пробел, если не предусмотрено) и возвращает список из подстроке; разделяет на num подстроку, если дано.
32splitlines( num=string.count(‘\n’)) – Разбивает строку на все (или числа) строки и возвращает список каждой строки с удаленными символами новой строки.
33startswith(str, beg=0,end=len(string)) – Определяет, является ли строка или подстрока в строке (если начальный индекс нач и заканчивается указанием на конец) начинается с подстроки str; возвращает истину, если так и ложь в противном случае.
34strip([chars]) – Выполняет как lstrip() и rstrip() в строке
35swapcase() – Инверсия для всех букв в строке.
36title() – Возвращает «titlecased» версию строки, то есть, все слова начинаются с верхним регистром, а остальное в нижнем регистре.
37translate(table, deletechars=””) – Переводит строку согласно таблице перевода str(256 символов), убрав deletechars.
38upper() – Преобразование строчных букв в строке в верхний регистр.
39zfill (width) – Возвращает исходную строку добавленную слева с нулями с указанной шириной символов; предназначенный для чисел, zfill() сохраняет любой данный знак (менее один ноль).
40isdecimal() – Возвращает истину, если строка содержит только десятичные знаки и ложь в противном случае.

 

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

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

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

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

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

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

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

Вывод:

 

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

Вывод:

 

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

 

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

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

МетодTrue если
str.isalnum()Строка состоит только из буквенно-цифровых символов (без специальных символов).
str.isalpha()Строка состоит только из буквенных символов (без специальных символов).
str.islower()Все буквенные символы строки имеют нижний регистр.
str.isnumeric()Строка состоит только из цифровых символов.
str.isspace()Строка состоит только из символов пробелов.
str.istitle()Строка заглавными буквами.
str.isupper()Все буквенные символы строки имеют верхний регистр.

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

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. Для наглядности ниже они представлены в таблице:

Название

Описание

String.upper()

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

String.lower()

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

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

Определяет число вхождений подстроки в строке

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

Возвращает индекс первого найденного вхождения

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

Возвращает индекс первого найденного вхождения при поиске справа

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

Возвращает индекс первого найденного вхождения

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

Заменяет подстроку old на new

String.isalpha()

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

String.isdigit()

Определяет: состоит ли строка целиком из цифр

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

Расширяет строку, добавляя символы слева

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

Расширяет строку, добавляя символы справа

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

Разбивает строку на подстроки

String.join(список)

Объединяет коллекцию в строку

String.strip()

Удаляет пробелы и переносы строк справа и слева

String.rstrip()

Удаляет пробелы и переносы строк справа

String.ltrip()

Удаляет пробелы и переносы строк слева

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

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 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:]. Аналогично если оп

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

Поскольку число положительных отзывов превысило число отрицательных, продолжу выкладывание уроков. Те кто уже знаком с основами — можете или просто пропустить урок, или попробовать сделать задание 3 самым коротким способом 🙂

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

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

# -*- coding: cp1251 -*-

или использовать для хранения исходных текстов файлы utf-8 (что предпочтительней).

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

Строки


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

Лучший способ запомнить, как определяются индексы в срезе — считать их указывающими между символами, с номером 0 на левой границе первого символа. А правая граница последнего символа имеет индекс равный длине строки.
Для положительных символов длина строки равна разности между числами на границе.

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

Unicode

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

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

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

Кроме того, Пайтон позволяет создать строку в Unicode с помощью одноименной функции.
>>> uni = unicode("Тест", "UTF-8")
>>> uni
u'\u0422\u0435\u0441\u0442'

Эта функция функция может работать с Latin-1, ASCII, UTF-8, UTF-16, с русскими кодировками ISO-8859-5, KOI8-R, CP1251, CP866 и Mac-cyrillic, и многими другими.

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

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

Для преобразования строки в список по определенному разделителю, используется метод split.
Этот метод в качестве параметра запрашивает разделитель, а возвращает список отдельных «слов» по которому можно «пройти» в цикле for.
>>> 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
Кстати, регулярные выражения использовать в этих заданиях — нельзя 🙂

string — Общие строковые операции — Документация Python 3.8.5

Исходный код: Lib / string.py


Строковые константы

Константы, определенные в этом модуле:

Строка ascii_letters

Конкатенация ascii_lowercase и ascii_uppercase Константы описаны ниже. Это значение не зависит от локали.

Строка ascii_lowercase

Строчные буквы 'abcdefghijklmnopqrstuvwxyz' . Это значение не зависит от локали и не изменится.

Строка ascii_uppercase

Прописные буквы 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' . Это значение не зависит от локали и не изменится.

Строка цифр

Строка '0123456789' .

Строка шестнадцатеричные

Строка '0123456789abcdefABCDEF' .

Строка окт. Цифр

Струна '01234567' .

Строка пунктуация

Строка символов ASCII, которые считаются знаками препинания в локали C : ! "# $% & '() * +, -._` {|} ~ .

Строка для печати

Строка символов ASCII, которые считаются печатными. Это комбинация из цифр, , , ascii_letters , , пунктуация , и пробелов .

Строка пробелов

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

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

Встроенный строковый класс предоставляет возможность делать сложные переменные замены и форматирование значения с помощью метода format (), описанного в PEP 3101 . Класс Formatter в модуле string позволяет вам создавать и настраивать свои собственные поведения форматирования строки, используя тот же реализация в виде встроенного метода () метод .

класс строка. Форматер

Класс Formatter имеет следующие открытые методы:

формат ( format_string , /, * args , ** kwargs )

Основной метод API. Требуется строка формата и произвольный набор позиционных и ключевых аргументов. Это просто оболочка, которая вызывает vformat () .

vformat ( format_string , args , kwargs )

Эта функция выполняет фактическую работу по форматированию.Это выставлено как отдельная функция для случаев, когда вы хотите передать предопределенный словарь аргументов, а не распаковывать и перепаковывать словарь в качестве отдельных аргументов с использованием *, аргументы и **, kwargs синтаксис. vformat () разбивает строку формата в символьные данные и поля замены. Это вызывает различные методы описаны ниже.

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

парс ( format_string )

Зацикливается на format_string и возвращает итерацию кортежей ( literal_text , field_name , format_spec , преобразование ).Это используется на vformat () , чтобы разбить строку либо на текст, либо замена полей.

Значения в кортеже концептуально представляют диапазон буквального текста с последующим одним полем замены. Если нет буквального текста (что может произойти, если два замещающих поля появляются последовательно), тогда literal_text будет строкой нулевой длины. Если нет замены поле, затем значения имя_поля , формат_спец и преобразование будет Нет .

get_field ( field_name , args , kwargs )

Учитывая имя_поля , возвращенное parse () (см. Выше), преобразовать его в объект для форматирования. Возвращает кортеж (obj, used_key). По умолчанию версия принимает строки в форме, определенной в PEP 3101 , такой как «0 [имя]» или «label.title». args и kwargs соответствуют vformat () .Возвращаемое значение used_key имеет то же значение, что и ключ параметр до get_value () .

get_value ( ключ , args , kwargs )

Получить заданное значение поля. ключ аргумент будет либо целое число или строка. Если это целое число, оно представляет индекс позиционный аргумент в args ; если это строка, то она представляет названный аргумент в kwargs .

Параметр args устанавливается в список позиционных аргументов для vformat () , а параметр kwargs установлен в словарь ключевые аргументы.

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

Так, например, выражение поля «0.name» будет вызывать get_value () вызывается с ключом аргументом 0.Название Атрибут будет найден после get_value () возвращает вызов встроенная функция getattr () .

Если индекс или ключевое слово относится к элементу, который не существует

.

Python Strings


Строковые литералы

Строковые литералы в python заключены в одинарные или двойные кавычки.

«привет» - это то же самое, что и «привет».

Строковый литерал можно отобразить с помощью функции print () :


Присвоить строку переменной

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


Многострочные строки

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

Пример

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

a = "" "Lorem ipsum dolor sit amet,
человек, участвующий в программе elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."" "
print (a)

Попробуй сам "

Или три одинарные кавычки:

Пример

a = '' 'Lorem ipsum dolor sit amet,
человек, участвующий в программе elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. '' '
print (a)

Попробуй сам "

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



Струны - Массивы

Как и многие другие популярные языки программирования, строки в Python представляют собой массивы байтов, представляющих символы Юникода.

Однако у Python нет символьного типа данных, один символ - это просто строка длиной 1.

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

Пример

Получить символ в позиции 1 (помните, что первый персонаж имеет позиция 0):

a = "Привет, мир!"
печать (а [1])

Попробуй сам "

Нарезка

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

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

Пример

Получить символы с позиции 2 до позиции 5 (не включены):

b = "Привет, мир!"
Печать (б [2: 5])

Попробуй сам "

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

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

Пример

Получить символы с позиции 5 до позиции 1 (не включены), начиная отсчет с конец строки:

b = "Привет, мир!"
печать (б [-5: -2])

Попробуй сам "

Длина строки

Чтобы получить длину строки, используйте функцию len () .

Пример

Функция len () возвращает длину строки:

a = "Привет, мир!"
печать (LEN (а))

Попробуй сам "

Строковые методы

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

Пример

Метод strip () удаляет любые пробелы в начале или конце:

a = "Привет, мир!"
печать (а.strip ()) # возвращает "Hello, World!"

Попробуй сам "

Пример

Метод lower () возвращает строку в нижнем регистре:

a = "Привет, мир!"
печать (a.lower ())

Попробуй сам "

Пример

Метод upper () возвращает строку в верхнем регистре:

a = "Привет, мир!"
печать (a.upper ())

Попробуй сам "

Пример

Метод replace () заменяет строку другой строкой:

a = "Привет, мир!"
печать (а.заменить («Н», «J»))

Попробуй сам "

Пример

Метод split () разбивает строку на подстроки, если он находит экземпляры разделителя:

a = "Привет, мир!"
print (a.split (",")) # возвращает ['Hello', 'World!']

Попробуй сам "

Узнайте больше о строковых методах с нашей справочником по строковым методам


Контрольная строка

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

Пример

Проверьте, присутствует ли в следующем тексте фраза «ain»:

txt = "Дождь в Испании держится в основном на равнине"
x = "ain" в txt
печать (х)

Попробуй сам "

Пример

Проверьте, нет ли в следующем тексте фразы «ain»:

txt = "Дождь в Испании держится в основном на равнине"
x = "ain" не в текстовом
печать (х)

Попробуй сам "

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

Чтобы объединить или объединить две строки, вы можете использовать оператор +.

Пример

Объединение переменных и с переменными b в переменную c :

a = "Hello"
b = "World"
c = a + b
печать (с)

Попробуй сам "

Пример

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

a = "Hello"
b = "World"
c = a + "" + b
печать (с)

Попробуй сам "

Строка Формат

Как мы узнали из главы «Переменные Python», мы не можем комбинировать строки и числа следующим образом:

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

Метод () метод принимает переданные аргументы, форматирует их и помещает их в строку, где заполнители {} являются:

Пример

Используйте метод () метод для вставки чисел в строки:

age = 36
txt = "Меня зовут Джон, и я {}"
print (txt.формат (возраст))

Попробуй сам "

Метод format () принимает неограниченное количество аргументов и помещается в соответствующие заполнители:

Пример

количество = 3
itemno = 567
цена = 49,95
myorder = "Я хочу {} штук {} за {} долларов. "
print (myorder.format (количество, пунктно, цена))

Попробуй сам "

Вы можете использовать номера индекса {0} , чтобы убедиться, что аргументы размещены в правильных заполнителях:

Пример

Количество = 3
шт. = 567
цена = 49.95
myorder = "Я хочу заплатить {2} долларов за {0} единиц товара {1}. "
print (myorder.format (количество, пунктно, цена))

Попробуй сам "

Escape Character

Чтобы вставить недопустимые символы в строку, используйте escape-символ.

Экранирующий символ - это обратный слеш \ , за которым следует символ, который вы хотите вставить.

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

Пример

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

txt = "Мы так называемые" викинги "с севера."

Попробуй сам "

Чтобы решить эту проблему, используйте escape-символ \ ":

Пример

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

txt = "Мы так называемые \" викинги \ "с севера."

Попробуй сам "

Другие экранирующие символы, используемые в Python:


Строковые методы

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

Примечание: Все строковые методы возвращают новые значения. Они не меняют исходную строку.

Метод Описание
capitalize () Преобразует первый символ в верхнем регистре
casefold () Преобразует строку в строчная
center () Возвращает по центру строка
count () Возвращает количество раз указанное значение встречается в строке
encode () Возвращает закодированный версия строки
endwith () Возвращает true, если строка заканчивается указанным значением
expandtabs () Устанавливает размер вкладки строки
find () Ищет строку для указанное значение и возвращает позицию, где оно было найдено
формат () Заданные форматы значения в строке
format_map () Заданные форматы значения в строке
index () Поиск строки для указанного значения и возвращает позицию, где оно было найдено
isalnum () Возвращает True, если все символы в строке являются буквенно-цифровыми
isalpha () Возвращает True, если все символы в строке в алфавите
isdecimal () Возвращает True, если все символы в строке являются десятичными
isdigit () Возвращает True, если все символы в строке являются цифрами
isidentifier () Возвращает True, если строка является идентификатором
islower () Возвращает True, если все символы в строке строчные
isnumeric () Возвращает True, если все символы в строке являются числовыми
isprintable () Возвращает True, если все символы в строке для печати
isspace () Возвращает True, если все символы в строке являются пробелами
istitle () Возвращает True, если строка соответствует правилам название
isupper () Возвращает True, если все символы в строке в верхнем регистре
join () Присоединяет элементы итерируемый до конца строки
ljust () Возвращает выравнивание по левому краю версия строки
lower () Преобразует строку в строчная
lstrip () Возвращает левую обрезку версия строки
maketrans () Возвращает таблица перевода для использования в переводах
partition () Возвращает кортеж где строка разделена на три части
replace () Возвращает строку где указанное значение заменено на указанное значение
rfind () Ищет строку для указанное значение и возвращает последнюю позицию, где оно было найдено
rindex () Ищет строку для указанное значение и возвращает последнюю позицию, где оно было найдено
rjust () Возвращает оправданное право версия строки
rpartition () Возвращает кортеж где строка разделена на три части
rsplit () Разбивает строку в указанный разделитель и возвращает список
rstrip () Возвращает правильную отделку версия строки
split () Разбивает строку в указанный разделитель и возвращает список
splitline () Разбивает строку при разрыве строки и возвращает список
startwith () Возвращает true, если строка начинается с указанного значения
strip () Возвращает усеченную версию строки
swapcase () Сменные футляры, нижние регистр становится заглавным и наоборот
title () Преобразует первый символ каждого слова в верхнем регистре
translate () Возвращает переведенная строка
upper () Преобразует строку в верхний регистр
zfill () Заполняет строку указанное число 0 значений в начале


,
Улучшенный синтаксис форматирования строк (Руководство) - Real Python

Начиная с Python 3.6, f-строки - отличный новый способ форматирования строк. Они не только более читабельны, более кратки и менее подвержены ошибкам, чем другие способы форматирования, но и быстрее!

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

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

«Старая школа» Форматирование строк в Python

До Python 3.6 у вас было два основных способа встраивания выражений Python в строковые литералы для форматирования:% -форматирование и str.format () . Вы увидите, как их использовать и каковы их ограничения.

Вариант № 1:% форматирование

Это OG форматирования Python и существует на языке с самого начала. Вы можете прочитать больше в документации по Python. Имейте в виду, что% -форматирование не рекомендуется документами, которые содержат следующее примечание:

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

Использование более новых форматированных строковых литералов или интерфейса str.format () помогает избежать этих ошибок. Эти альтернативы также предоставляют более мощные, гибкие и расширяемые подходы к форматированию текста ». (Источник)

Как использовать% -форматирование

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

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

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

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

Примеры кода, которые вы только что видели выше, достаточно читабельны. Однако, как только вы начнете использовать несколько параметров и более длинные строки, ваш код быстро станет менее читаемым.Все начинает выглядеть немного грязно:

>>>
  >>> first_name = "Эрик"
>>> last_name = "Idle"
  
.
6.1. string - Общие строковые операции - Документация Python 3.4.10

Исходный код: Lib / string.py


6.1.1. Строковые константы

Константы, определенные в этом модуле:

string.ascii_letters

Объединение ascii_lowercase и ascii_uppercase Константы описаны ниже. Это значение не зависит от локали.

string.ascii_lowercase

Строчные буквы 'abcdefghijklmnopqrstuvwxyz'.Это значение не зависит от локали и не изменится.

string.ascii_uppercase

Прописные буквы 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Это значение не зависит от локали и не изменится.

string.digits

Строка '0123456789'.

string.hexdigits

Строка '0123456789abcdefABCDEF'.

строка.octdigits

Строка '01234567'.

строка.пунктуация

Строка символов ASCII, которые считаются знаками препинания в локали С

string.printable

Строка символов ASCII, которые считаются печатными. Это комбинация цифр, ascii_letters, пунктуация, и пробелы.

string.whitespace

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

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

Встроенный строковый класс предоставляет возможность делать сложные переменные замены и форматирование значений с помощью метода format (), описанного в PEP 3101 . Класс Formatter в строковом модуле позволяет вам создавать и настраивать свои собственные поведения форматирования строки, используя тот же реализация как встроенный метод format ().

класс строка. Формат

Класс Formatter имеет следующие открытые методы:

формат ( format_string , * args , ** kwargs )
Формат

() является основным методом API. Требуется строка формата и произвольный набор позиционных и ключевых аргументов. format () - это просто оболочка, которая вызывает vformat ().

vformat ( format_string , args , kwargs )

Эта функция выполняет фактическую работу по форматированию.Это выставлено как отдельная функция для случаев, когда вы хотите передать предопределенный словарь аргументов, а не распаковывать и перепаковывать словарь в качестве отдельных аргументов с использованием * args и ** kwargs синтаксис. vformat () разбивает строку формата в символьные данные и поля замены. Это вызывает различные методы описаны ниже.

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

синтаксический анализ ( формат_строки )

Зацикливается на format_string и возвращает итерацию кортежей ( literal_text , field_name , format_spec , преобразование ).Это используется с помощью vformat () разбить строку на буквальный текст, или замена полей.

Значения в кортеже концептуально представляют диапазон буквального текста с последующим одним полем замены. Если нет буквального текста (что может произойти, если два замещающих поля появляются последовательно), тогда literal_text будет строкой нулевой длины. Если нет замены затем значения field_name , format_spec и преобразования Никто не будет

get_field ( field_name , args , kwargs )

Если задано имя_поля как возвращено parse () (см. Выше), преобразуйте его в объект для форматирования. Возвращает кортеж (obj, used_key). По умолчанию версия принимает строки в форме, определенной в PEP 3101 , такой как «0 [имя]» или «label.title». арг и карг как переданы в vformat (). Возвращаемое значение used_key имеет то же значение, что и ключ параметр для get_value ().

get_value ( key , args , kwargs )

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

Параметр args устанавливается в список позиционных аргументов для vformat (), а параметр kwargs устанавливается в словарь ключевые аргументы.

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

Так, например, выражение поля «0.name» будет вызывать get_value () вызывается с ключом и аргументом , равным 0. Имя атрибут будет найден после возврата get_value () путем вызова встроенная функция getattr ().

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

check_unused_args ( used_args , args , kwargs )

Реализовать проверку неиспользованных аргументов, если это необходимо. Аргументы к этому Функция - это набор всех ключей аргументов, которые на самом деле упоминались в строка формата (целые числа для позиционных аргументов и строки для именованные аргументы), а также ссылка на арг и карг , которая была перешел на вформат. Набор неиспользованных аргументов можно рассчитать по этим параметры.Предполагается, что check_unused_args () вызывает исключение, если проверка не проходит.

поле_формата (значение , , формат , спецификация )
.