Работа в питоне со строками: Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы

Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы

Петр Смолович

ведущий разработчик хостинг-провайдера и регистратора доменов REG.RU

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

Итак, мы на собеседовании, и я хочу узнать, умеете ли вы обращаться со строками.

Как склеить две строки?

>>> s = "abc" + "def"
>>> s += "xyz"

Элементарно? Почти. Важно помнить, что строки — это неизменяемые объекты. Каждый раз, когда мы говорим про «изменение» строки, технически мы создаем новый объект и записываем туда вычисленное значение.

А как склеить три строки? Напрашивается ответ «точно так же», и иногда это самый лучший способ. Но интервьюер скорее всего хочет проверить, знаете ли вы про метод .join().

>>> names = ["John", "Paul", "Ringo", "George"]
>>> ", ".join(names)
'John, Paul, Ringo, George'

join() — очень удобный метод, позволяющий склеить N строк, причём с произвольным разделителем.

Здесь важно не только получить результат, но и понимать, как работает приведённая конструкция. А именно, что join() — это метод объекта «строка», принимающий в качестве аргумента список и возвращающий на выходе новую строку.
Кстати, хорошая задачка для интервью — написать свою реализацию join().

Разделить строки?

Есть несколько способов получить часть строки. Первый — это split, обратный метод для join. В отличие от join’а, он применяется к целевой строке, а разделитель передаётся аргументом.

>>> s = "Альфа, Браво, Чарли"
>>> s. split(", ")
['Альфа', 'Браво', 'Чарли']

Второй — срезы (slices).

Срез s[x:y] позволяет получить подстроку с символа x до символа y. Можно не указывать любое из значений, чтобы двигаться с начала или до конца строки. Отрицательные значения используются для отсчёта с конца (-1 — последний символ, -2 — предпоследний и т.п.).

>>> s = "Hello, world!"
>>> print(s[0:5])
Hello
>>> print(s[-6:])
world!

При помощи необязательного третьего параметра s[x:y:N] можно выбрать из подстроки каждый N-ый символ. Например, получить только чётные или только нечётные символы:

>>> s = "0123456789"
>>> print(s[::2])
02468
>>> print(s[1::2])
13579

Что насчёт поиска в строке?

Самое быстрое — проверить, начинается ли (заканчивается ли) строка с выбранных символов. Для этого в Python предусмотрены специальные строковые методы. /]+)(.*)$», s)
>>> print(result.group(1))
https
>>> print(result.group(2))
www.reg.ru
>>> print(result.group(3))
/hosting/

А замену в строке сделать сможете?

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

>>> s = "Hello, darling! How are you?"
>>> s[:7] + "Василий" + s[14:]
'Hello, Василий! How are you?'

Во-вторых, умеешь find(), умей и replace().

>>> s.replace("darling", "Василий")
'Hello, Василий! How are you?'

В-третьих, любую проблему можно решить регулярными выражениями. Либо получить две проблемы 🙂 В случае с заменой вам нужен метод re.sub().

>>> s = "https://www.reg.ru/hosting/";
>>> import re
>>> print(re.sub('[a-z]', 'X', s))
XXXXX://XXX.XXX.XX/XXXXXXX/

Посимвольная обработка?

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

>>> s = "Hello, world!"
>>> for c in s:
>>>     if c == "o":
>>>         counter += 1
>>> print(counter)
2

Иногда удобнее бежать по индексу.

>>> for i in range(len(s)):
>>>     if s[i] == "o":
>>>         counter += 1

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

>>> s[i] = "X"
Traceback (most recent call last):
File "", line 1, in 
TypeError: 'str' object does not support item assignment
>>> s[:i] + "X" + s[i+1:]
'HellX, world!'

Либо можно преобразовать строку в список, сделать обработку, а потом склеить список обратно в строку:

>>> arr = list(s)
>>> "".join(arr)
'Hello, world!'

А форматирование строк?

Типичная жизненная необходимость — сформировать строку, подставив в неё результат работы программы. Начиная с Python 3.6, это можно делать при помощи f-строк:

>>> f"Строка '{s}' содержит {len(s)} символов."
"Строка 'Hello, world!' содержит 13 символов."

В более старом коде можно встретить альтернативные способы

>>> "Строка '%s' содержит %d символов" % (s, len(s))
>>> "Строка '{}' содержит {} символов".format(s, len(s))

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

>>> "Строка '" + s + "' содержит " + str(len(s)) + " символов."
"Строка 'Hello, world!' содержит 13 символов."

***

Цель работодателя на собеседовании — убедиться что вы соображаете и что вы справитесь с реальными задачами. Однако погружение в реальные задачи занимает несколько недель, а время интервью ограничено. Поэтому вас ждут учебные задания, которые можно решить за 10-30 минут, а также вопросы на понимание того, как работает код. О них и поговорим в следующей части.

Строки. Урок 19 курса «Python. Введение в программирование»

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

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

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

>>> s = "Hello, World!"
>>> s[0]
'H'
>>> s[7:]
'World!'
>>> s[::2]
'Hlo ol!'

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

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

>>> s[-1] = '.'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support 
item assignment

Интерпретатор сообщает, что объект типа str не поддерживает присвоение элементам.

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

>>> s = s[0:-1] + '.'
>>> s
'Hello, World.'

В примере берется срез из исходной строки, соединяется с другой строкой. Получается новая строка, которая присваивается переменной s. Ее старое значение при этом теряется.

Методы строк

В Python для строк есть множество методов. Посмотреть их можно по команде dir(str), получить информацию по каждому – help(str. имя_метода). Рассмотрим наиболее интересные из них.

Методы split() и join()

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

>>> s = input()
red blue orange white
>>> s
'red blue orange white'
>>> sl = s.split()
>>> sl
['red', 'blue', 'orange', 'white']
>>> s
'red blue orange white'

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

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

>>> s.split('e')
['r', 'd blu', ' orang', ' whit', '']
>>> '40030023'. split('00')
['4', '3', '23']

Метод строк join() выполняет обратное действие. Он формирует из списка строку. Поскольку это метод строки, то впереди ставится строка-разделитель, а в скобках — передается список:

>>> '-'.join(sl)
'red-blue-orange-white'

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

>>> ''.join(sl)
'redblueorangewhite'

Методы find() и replace()

Данные методы строк работают с подстроками. Методы find() ищет подстроку в строке и возвращает индекс первого элемента найденной подстроки. Если подстрока не найдена, то возвращает -1.

>>> s
'red blue orange white'
>>> s.find('blue')
4
>>> s.find('green')
-1

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

>>> letters = 'ABCDACFDA'
>>> letters. find('A', 3)
4
>>> letters.find('DA', 0, 6)
3

Здесь мы ищем с третьего индекса и до конца, а также с первого и до шестого. Обратите внимания, что метод find() возвращает только первое вхождение. Так выражение letters.find('A', 3) последнюю букву ‘A’ не находит, так как ‘A’ ему уже встретилась под индексом 4.

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

>>> letters.replace('DA', 'NET')
'ABCNETCFNET'

Исходная строка, конечно, не меняется:

>>> letters
'ABCDACFDA'

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

>>> new_letters = letters.replace('DA', 'NET')
>>> new_letters
'ABCNETCFNET'

Метод format()

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

>>> print("This is a {0}. It's {1}."
... .format("ball", "red"))
This is a ball.  It's red.

Однако к print() он никакого отношения не имеет, а применяется к строкам. Лишь потом заново сформированная строка передается в функцию вывода.

Возможности format() широкие, рассмотрим основные.

>>> size1 = "length - {}, width - {}, height - {}"
>>> size1.format(3, 6, 2.3)
'length - 3, width - 6, height — 2.3'

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

>>> size2 = "height - {2}, length - {0}, width - {1}"
>>> size2.format(3, 6, 2.3)
'height - 2.3, length - 3, width - 6'

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

>>> info = "This is a {subj}. It's {prop}."
>>> info.format(subj="table", prop="small")
"This is a table. It's small."

Пример форматирования вещественных чисел:

>>> "{1:. 2f} {0:.3f}".format(3.33333, 10/6)
'1.67 3.333'

Практическая работа

1. Вводится строка, включающая строчные и прописные буквы. Требуется вывести ту же строку в одном регистре, который зависит от того, каких букв больше. При равном количестве преобразовать в нижний регистр. Например, вводится строка «HeLLo World», она должна быть преобразована в «hello world», потому что в исходной строке малых букв больше. В коде используйте цикл for, строковые методы upper() (преобразование к верхнему регистру) и lower() (преобразование к нижнему регистру), а также методы isupper() и islower(), проверяющие регистр строки или символа.

2. Строковый метод isdigit() проверяет, состоит ли строка только из цифр. Напишите программу, которая запрашивает с ввода два целых числа и выводит их сумму. В случае некорректного ввода программа не должна завершаться с ошибкой, а должна продолжать запрашивать числа. Обработчик исключений try-except использовать нельзя.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Практическая работа по информатике «Работа со строками, списками, словарями в Python»

Практическая работа №

«Работа со строками, списками, словарями в Python»

Цель работы: научиться применять операции конкатенация, дублирование с различными типами данных; использовать при решении задач специальную функцию len при работе с различными типами данных; извлекать символы, объекты с помощью оператора индексирования; получать срез в различных типах данных.

Задания:

1. Присвойте переменной str строку «Основы алгоритмизации и программирования»
2. Присвойте переменной w строку «- группа №»
3. Примените операцию конкатенация к этим двум строкам. Присвойте результат новой переменной r.
4. Продублируйте строку r 6 раз.
5. Чему равна длина строки r? Выведите на экран.
6. Выполните срез
7. с первого символа по шестой символ;
8. с последнего символа по пятый символ;
9. с первого по последний элемент, с шагом 5.
10. d – строка. Что означает запись d[::8]? Выведите на экран результат и присвойте переменной e.
11. Переменная G – список, состоящий из строк, 8 строк. Создайте список G.
12. Переменная Spisok – список, состоящий из дробных чисел, 10 дробных чисел. Создайте список Spisok.
13. Отобразите на экране срез из списка Spisok с 1 элемента по 5 элемент.
14. Замените два элемента в списке G: 1 элемент на “hello”, 5 элемент на «Goodbye». Выведите список G на экран.
15. Создайте словарь J, отображающий информацию об успеваемости в вашей группе по дисциплине Информатика. В качестве ключа – отметка: 5,4,3,2; в качестве значения – количество обучающихся на эти отметки. Выведите на экран словарь J.
16. Добавьте новый элемент словаря: ключ – 1, значение -0. Выведите на экран словарь J.
17. Удалите любой элемент из словаря J. Выведите на экран.
18. Используйте срезы из строки str «Основы алгоритмизации и программирования» для того, чтобы выделить основные понятия дисциплины Основы алгоритмизации и программирования – это «алгоритм и программа» (используйте конкатенацию при выполнении данного задания). Сформулируйте определение каждого из понятий. Выведите на экран результат.
19. Свяжите переменную x со списком, состоящим из двух слов «алгоритм» и «программа». Создайте новый список из существующих: добавьте союз «и» между двумя словами алгоритм и программа. Выведите на экран результат.
20. Покажите работу преподавателю и ответьте на его вопросы.

Вопросы:

1. Как называются неизменяемые упорядоченные последовательности?
2. Как называются изменяемые упорядоченные последовательности?
3. Словарь – это … Продолжите
4. Интерпретатор выводит пары словаря в …. порядке. Добавьте слово вместо троеточия.
5. Назовите объекты списка?
6. Что такое индекс в строке?
7. Spis ={1:’python1’,2:’python2’}

Spis[3]=’python3’

Происходит … элемента … словарь. Заполните троеточие.

1. Spis ={1:’python1’,2:’python2’}

Del(Spis[2])’

Происходит … элемента …. словарь. Заполните троеточие.

1. Специальная функция, позволяющая измерить длину строки, списка?

Скачать — Практическая работа по информатике «Работа со строками, списками, словарями в Python»

Автор: Маркова Анна Викторовна
Должность: преподаватель
Место работы: ГАПОУ ПО «ПКИПТ» (ИТ-колледж)
Месторасположение: г. Пенза, Пензенская область

python1

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

Главный минус — питон, мягко говоря, не славится потрясающим быстродействием. Писать программы сложных вычислений на питоне, конечно, глупо. Но есть ряд способов обойти это ограничение. Если программа занимается регулярной обработкой больших массивов чисел с плавающей точкой, то использование numpy радикально повышает её быстродействие. Пакет numpy и его расширение scipy фактически делают matlab ненужным — дают ту же функциональность с более приятным языком программирование. Есть ряд пакетов для построения высококачественных графиков, например, matplotlib. Другое средство повышения быстродействия — cython. Пишется программа, выглядящая почти как питонская, но со вставленными статичестими декларациями типов. cython транслирует её в исходный код на C, что часто даёт быстродействие, сравнимое с вручную написанным C. Программа на cython-е может свободно вызывать функции из библиотек на C;
её можно использовать из обычного питона. Ну и наконец можно написать критически важные для быстродействия системы в целом вычисления на другом языке (C например), и вызывать эти внешние программы из питона. Питон при этом выполняет роль клея — реализует логику высокого уровня, системно-независимый GUI и т.д.

Питон — сильно типизированный язык с динамической типизацией. Всё, с чем работает программа — объекты; каждый из них принадлежит определённому типу. Если программа пытается выполнить какую-то операцию над объектом такого типа, который не поддерживает эту операцию, произойдёт ошибка времени выполнения. Описаний переменных в питоне нет. Одна и та же переменная может в разные моменты иметь значения — объекты разных типов. Ошибка в типах может проявиться много времени спустя после того, как программа сдана в эксплуатацию, особенно если она происходит в редко используемом участке кода.
Язык допускает ситуацию, когда мы сначала присвоим какой-то переменной целое число, потом строку, потом ещё что-то, но это плохой стиль. Переменная заводится для одного конкретного использования, и естественно, чтобы её значения в любой момент подходили для этого использования и имели одинаковый тип. В исходный текст на питоне 3.5 можно включить (необязательные) аннотации типов переменных и функций, и прогнать её через программу статической проверки типов.

В этом курсе мы познакомимся с основными конструкциями языка питон и наиболее часто используемыми функциями из стандартной библиотеки. Мы не будем пытаться охватить всё — если потребуется, недостающие факты всегда легко найти в справочной документации. Затем мы рассмотрим основные пакеты, используемые в научных вычислениях — numpy и scipy, matplotlib, пакет символьных вычислений sympy. Мы также обсудим использование cython-а для повышения быстродействия критических участков программы и для написания интерфейсов к библиотекам на C.

Каждая лекция представляет собой Jupyter-блокнот, см. http://jupyter.org/. Блокнот содержит последовательность ячеек. Некоторые из них содержат текст (включая картинки, формулы и т. д.), а некоторые — код. Кодовая ячейка состоит из поля ввода, помеченного In[$n$], и поля вывода, помеченного Out[$n$] (поле вывода может отсутствовать). Встав в поле ввода и нажав shift-enter, Вы пошлёте этот код интерпретатору питона; результат появится в поле вывода. Вы можете изменять примеры, приведённые в лекциях, и смотреть, что получится. Можно вставлять новые ячейки.

Некоторые полезные ссылки

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

Работа со строками в python

Python: работа со строками
Введение
Строки в языке Python являются типом данных, специально
предназначенным для обработки текстовой информации. Строка может
содержать произвольно длинный текст (ограниченный имеющейся
памятью).
Форматирование строк в Python
Существует четыре разных подхода к форматированию строк:
1. «Старый стиль» форматирования
строк (оператор %)
2. «Новый стиль» форматирования
строк (str.format)
3. Интерполяция строк / f-Strings
(Python 3.6+)
4. Шаблоны (Standard Library)
«Старый стиль»
форматирования строк
(оператор %)
«Старый стиль»
форматирования
строк
(оператор %)
Во многом аналогичен функции
printf в C.
Подробнее можно прочитать в
документации
https://docs.python.org/3/library/stdt
ypes.html#printf-style-stringformatting
name = «Eric»
«Hello, %s.» % name
Результат: Hello, Eric.
Поскольку оператор % принимает только
один аргумент, для случая с несколькими
переменными нужно обернуть правую часть
в кортеж, например, так:
name = «Eric»
age = 74
«Hello, %s. You are %s.» % (name, age)
Hello, Eric. You are 74.
Если переменных много, что код быстро
становиться плохо читаемым:
first_name = «Eric»
last_name = «Idle»
age = 74
profession = «comedian»
affiliation = «Monty Python»
«Hello, %s %s. You are %s. You are a %s. You were a member of %s.» %
(first_name, last_name, age, profession, affiliation)
Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty
Python.
Можно использовать
спецификатор формата
%x для преобразования
значения int в строку и
представления его в
виде
шестнадцатеричного
числа:
errno = 50159747054
name = ‘Bob’
‘Hey %s, there is a 0x%x error!’ %
(name, errno)
Результат:
Hey Bob, there is a 0xbadc0ffee error!
Также можно производить подстановку
переменных по имени:
‘Hey %(name)s, there is a 0x%(errno)x error!’ % {«name»: name, «errno»: errno }
Hey Bob, there is a 0xbadc0ffee error!
К сожалению, этот вид форматирования не очень хорош, потому что он
многословен и приводит к ошибкам, таким как неправильное
отображение кортежей или словарей.
Официальная документация Python 3 не рекомендует форматирование
«старого стиля» и говорит о нем не слишком любезно:
“The formatting operations described here exhibit a variety of quirks that lead
to a number of common errors (such as failing to display tuples and
dictionaries correctly). Using the newer formatted string literals or the
str.format() interface helps avoid these errors. These alternatives also provide
more powerful, flexible and extensible approaches to formatting text.” (Source)
https://docs.python.org/3/library/stdtypes.html?highlight=sprintf#printf-stylestring-formatting
«Новый стиль» (str.format)
«Новый стиль»
(str.format)
str.format () — это улучшение %
форматирования. Он
использует обычный
синтаксис вызова функции и
может быть расширен с
помощью переопределения
метода __format__() для
объекта, преобразуемого в
строку.
https://www.python.org/dev/pep
s/pep-3101/#controllingformatting-on-a-per-type-basis
Был представлен в Python 2.6
https://docs.python.org/3/library/stdtypes.html#str.format
Поля замены отмечены фигурными
скобками:
«Hello, {}. You are {}.».format(name, age)
Hello, Bob. You are 74.
Можно ссылаться на переменные в
любом порядке, используя их индекс:
«Hello, {1}. You are {0}.».format(age, name)
Hello, Bob. You are 74.
Но если вы вставите
имена переменных, вы
получите
дополнительную
возможность
передавать объекты, а
затем ссылаться на
параметры и методы
между фигурными
скобками:
person = {‘name’: ‘Eric’, ‘age’: 74}
«Hello, {name}. You are
{age}.».format(name=person[‘name’],
age=person[‘age’])
Hello, Eric. You are 74.
Также часто удобно использовать ** , для вывода
значений из словаря:
«Hello, {name}. You are
{age}.».format(**person)
Hello, Eric. You are 74.
Недостатки: Хотя код, использующий str.format (), гораздо легче
читается, в сравнении с %-форматированием, однако str.format ()
все еще может быть слишком громоздким, когда строка длинная
и параметров много.
first_name = «Eric»
last_name = «Idle»
age = 74
profession = «comedian»
affiliation = «Monty Python»
print((«Hello, {first_name} {last_name}. You are {age}. » +
«You are a {profession}. You were a member of {affiliation}.») \
.format(first_name=first_name, last_name=last_name, age=age, \
profession=profession, affiliation=affiliation))
Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.
f-Strings / Интерполяция строк
f-Strings:
https://docs.python.org/3/referenc
e/lexical_analysis.html#f-strings
новый и улучшенный
способ
форматирования строк
в Python
name = «Eric»
age = 74
Поддержка добавлена
начиная с Python 3.6.
Вы можете прочитать
все об этом в PEP 498.
https://www.python.org/
dev/peps/pep-0498/
f»Hello, {name}. You are {age}.»
Hello, Eric. You are 74.
Произвольные
выражения:
Поскольку f-строки
вычисляются во
время выполнения, в
них можно
поместить все
допустимые
выражения Python.
https://docs.python.org/3/reference/lexica
l_analysis. html#f-strings
print( f»{2 * 37}» )
74
def to_lowercase(input):
return input.lower()
name = «Eric Idle»
print(f»{to_lowercase(name)} is funny.»)
eric idle is funny.
Можно вызвать метод напрямую:
print( f»{name.lower()} is funny.» )
eric idle is funny.
Другой пример:
print(f’Если поделить торт на трех человек,
каждый из них получит {1/3*100:.2f} %’)
Если поделить торт на трех человек,
каждый из них получит 33.33 %
Пример с классом:
class Comedian:
def __init__(self, first_name, last_name, age):
self.first_name = first_name
self.last_name = last_name
self.age = age
def __str__(self):
return f»{self.first_name} {self.last_name} is {self.age}.»
def __repr__(self):
return f»{self.first_name} {self.last_name} is {self.age}. Surprise!»
new_comedian = Comedian(«Eric», «Idle», «74»)
print(f»{new_comedian}»)
Eric Idle is 74.
print(f»{new_comedian!r}»)
Eric Idle is 74. Surprise!
Многострочные f-строки
name = «Eric»
profession = «comedian»
affiliation = «Monty Python»
message = (
f»Hi {name}. «
f»You are a {profession}. «
f»You were in {affiliation}.»
)
print(message)
Hi Eric. You are a comedian. You were in Monty Python.
Важно, чтобы f было перед каждой строкой
многострочной строки. Следующий код не будет
работать:
message = (
f»Hi {name}. «
«You are a {profession}. «
«You were in {affiliation}.»
)
print(message)
Hi Eric. You are a {profession}. You were in {affiliation}.
При использовании «»» строк:
message = f»»»
Hi {name}.
You are a {profession}.
You were in {affiliation}.
«»»
print(message)
Hi Eric.
You are a comedian.
You were in Monty Python.
Скорость
Символ f в f-string
также может означать
«быстро» (fast).
f-строки быстрее, чем
%-форматирование и
str.format().
f-строки — это
выражения,
вычисляемые во время
выполнения.
import timeit
timeit.timeit(«»»name = «Eric» age = 74 ‘%s is %s.’
% (name, age)»»», number = 10000)
0.004173202378340368
timeit.timeit(«»»name = «Eric» age = 74 ‘{} is
{}.’.format(name, age)»»», number = 10000)
0.00488798551082123
timeit.timeit(«»»name = «Eric» age = 74 f'{name}
is {age}.'»»», number = 10000)
0.0025852118251977196
Может быть потенциально небезопасно, если строка получается от
пользователя.
# Это наш супер секретный ключ:
SECRET = ‘this-is-a-secret’
class Error:
def __init__(self):
pass
# Злонамеренный пользователь может ввести строку, которая
# может прочитать данные из глобального пространства имен:
user_input = ‘{error.__init__.__globals__[SECRET]}’
# Что позволит получить секретную информацию,
# такую как секретный ключ:
err = Error()
print(user_input.format(error=err))
this-is-a-secret
Шаблонные строки
(Стандартная библиотека
Template Strings)
Шаблоны
(Standard Library)
Еще один инструмент
для форматирования
строк в Python:
шаблоны. Был
добавлен в Python 2.4.
Это более простой и
менее мощный
механизм, но в
некоторых случаях это
может быть именно то,
что нужно.
from string import Template
t = Template(‘Hey, $name!’)
s = t.substitute(name=name)
print(s)
Hey, Eric Idle!
Нужно импортировать класс Template из встроенного строкового модуля
Python. Шаблонные строки не являются основной функцией языка, но
они предоставляются модулем строк в стандартной библиотеке.
https://docs.python.org/3/library/string.html
Каким методом
форматирования
строк стоит
пользоваться?
Если строки получены от
пользователя, используйте
шаблонные строки (способ 4),
чтобы избежать проблем с
уязвимостью программы.
Другое отличие состоит в том, что строки шаблона не
допускают спецификаторов формата.
templ_string = ‘Hey $name, there is a $error error!’
s = Template(templ_string).substitute(name=name,
error=hex(errno))
print(s)
Hey Eric Idle, there is a 0xbadc0ffee error!
Отступы и выравнивание строк
Добавить отступы слева:
test = ‘test’
print(‘%10s’ % (test,))
print(‘{:>10}’. +10.2f}’)
__+42.00__
Пробел означает, что для отрицательного значения
будет отображен минус, а для положительного пробел.
print(‘{: d}’.format((- 23)))
print(‘{: d}’.format((23)))
print(f'{-23: d}’)
print(f'{23: d}’)
-23
23
-23
23
points = 19.5
total = 22
print(‘Correct answers: {:.2%}’.format(points/total))
print(f’Correct answers: {points/total:.2%}’)
Correct answers: 88.64%
Correct answers: 88.64%
Datetime:
from datetime import datetime
s = ‘{:%Y-%m-%d %H:%M}’.format(datetime(2001, 2, 3, 4, 5))
print(s)
2001-02-03 04:05
Datetime (f-строки):
from datetime import datetime
dt = datetime(2001, 2, 3, 4, 5)
s = f'{dt:%Y-%m-%d %H:%M}’
print(s)
2001-02-03 04:05
Встроенные методы строк в
python
string.capitalize()
приводит первую букву
в верхний регистр,
остальные в нижний.
Возвращает копию s с
первым символом,
преобразованным в
верхний регистр, и
остальными
символами,
преобразованными в
нижний регистр:
s = ‘everyTHing yoU Can IMaGine is
rEAl’
s. capitalize()
‘Everything you can imagine is real’
# Не алфавитные символы не
изменяются:
s = ‘follow us @PYTHON’
s.capitalize()
‘Follow us @python’
string.lower()
преобразует все
буквенные символы в
строчные.
Возвращает копию s со
всеми буквенными
символами,
преобразованными в
нижний регистр:
s = ‘everyTHing yoU Can IMaGine is
rEAl’
s.lower()
‘everything you can imagine is real’
string.swapcase()
возвращает копию s с
заглавными
буквенными
символами,
преобразованными в
строчные и наоборот:
s = ‘everyTHing yoU Can IMaGine is
rEAl’
s.swapcase()
‘EVERYthING YOu cAN imAgINE IS
ReaL’
string.title()
s = ‘the sun also rises’
s.title()
преобразует первые
буквы всех слов в
заглавные.
‘The Sun Also Rises’
возвращает копию, s в
которой первая буква
каждого слова
преобразуется в
верхний регистр, а
остальные буквы — в
нижний регистр:
string. upper()
s = ‘follow us @PYTHON’
s.upper()
преобразует все
буквенные символы в
заглавные.
‘FOLLOW US @PYTHON’
Возвращает копию s со
всеми буквенными
символами в верхнем
регистре:
Найти и заменить
подстроку в строке
Эти методы предоставляют различные способы
поиска в целевой строке указанной подстроки.
Каждый метод в этой группе поддерживает
необязательные аргументы и аргументы.
Они задают диапазон поиска: действие метода
ограничено частью целевой строки, начинающейся в
позиции символа и продолжающейся вплоть до
позиции символа , но не включая его. Если
указано, а нет, метод применяется к
части строки от конца.
string.count([
, [, ]])
подсчитывает
количество вхождений
подстроки в строку.
Возвращает количество
точных вхождений
подстроки в s:
‘foo goo moo’.count(‘oo’)
3
# Количество вхождений
изменится, если указать и
:
‘foo goo moo’. count(‘oo’, 0, 8)
2
string.endswith(
uffix>[, [,
]])
определяет,
заканчивается ли
строка заданной
подстрокой.
Возвращает, True если s
заканчивается
указанным и
False если нет:
>>> ‘python’.endswith(‘on’)
True
>>> ‘python’.endswith(‘or’)
False
# Сравнение ограничено
подстрокой, между и
, если они указаны:
>>> ‘python’.endswith(‘yt’, 0, 4)
True
>>> ‘python’.endswith(‘yt’, 2, 4)
False
Например, метод endswith() можно
использовать для проверки окончания
файла.
filenames = [«file.txt», «image.jpg», «str.txt»]
for fn in filenames:
if fn.lower().endswith(«.txt»):
print(fn)
file.txt
str.txt
string.find([,
[, ]])
ищет в строке
заданную подстроку.
Возвращает первый
индекс в s который
соответствует началу
строки :
>>> ‘Follow Us @Python’.find(‘Us’)
7
# Этот метод возвращает, -1 если
указанная подстрока не найдена:
>>> ‘Follow Us @Python’. find(‘you’)
-1
#Поиск в строке ограничивается
подстрокой, между и ,
если они указаны:
>>> ‘Follow Us @Python’.find(‘Us’, 4)
7
>>> ‘Follow Us @Python’.find(‘Us’, 4, 7)
-1
string.index([
, [, ]])
ищет в строке
заданную подстроку.
Этот метод идентичен
.find(), за исключением
того, что он вызывает
исключение ValueError,
если не найден:
>>> ‘Follow Us @Python’.index(‘you’)
Traceback (most recent call last):
File «», line 1, in
‘Follow Us @Python’.index(‘you’)
ValueError: substring not found
string.rfind([,
[, ]])
ищет в строке
заданную подстроку,
начиная с конца.
Возвращает индекс
последнего вхождения
подстроки в s,
который соответствует
началу :
>>> ‘Follow Us @Python’.rfind(‘o’)
15
# Как и в .find(), если подстрока не найдена,
возвращается -1:
>>> ‘Follow Us @Python’. rfind(‘a’)
-1
#Поиск в строке ограничивается
подстрокой, между и , если они
указаны:
>>> ‘Follow Us @Python’.rfind(‘Us’, 0, 14)
7
>>> ‘Follow Us @Python’.rfind(‘Us’, 9, 14)
-1
string.rindex(
[, [, ]])
ищет в строке
заданную подстроку,
начиная с конца.
Этот метод идентичен
.rfind(), за исключением
того, что он вызывает
исключение ValueError,
если не найден:
>>> ‘Follow Us @Python’.rindex(‘you’)
Traceback (most recent call last):
File «», line 1, in
‘Follow Us @Python’.rindex(‘you’)
ValueError: substring not found
string.startswith(
prefix>[, [,
]])
определяет, начинается
ли строка с заданной
подстроки.
Возвращает, True если s
начинается с
указанного и
False если нет:
>>> ‘Follow Us @Python’.startswith(‘Fol’)
True
>>> ‘Follow Us @Python’.startswith(‘Go’)
False
# Сравнение ограничено подстрокой, между
и , если они указаны:
>>> ‘Follow Us @Python’. startswith(‘Us’, 7)
True
>>> ‘Follow Us @Python’.startswith(‘Us’, 8, 16)
False
Классификация строк
Методы в этой группе классифицируют строку на
основе символов, которые она содержит.
string.isalnum()
определяет, состоит ли
строка из букв и цифр.
Возвращает True, если
строка s не пустая, а
все ее символы
буквенно-цифровые
(либо буква, либо
цифра). В другом
случае False :
>>> ‘abc123’.isalnum()
True
>>> ‘abc$123’.isalnum()
False
>>> ‘ ‘.isalnum()
False
string.isalpha()
>>> ‘ABCabc’.isalpha()
True
определяет, состоит ли
строка только из букв.
>>> ‘abc123’.isalpha()
False
Возвращает True, если
строка s не пустая, а
все ее символы
буквенные. В другом
случае False:
string.isdigit()
>>> ‘123’.isdigit()
True
определяет, состоит ли
строка из цифр
(проверка на число).
>>> ‘123abc’.isdigit()
False
Возвращает True когда
строка s не пустая и все
ее символы являются
цифрами, а в False если
нет:
string.isidentifier()
определяет, является
ли строка допустимым
идентификатором
Python.
Возвращает True, если s
валидный
идентификатор
(название переменной,
функции, класса и т.д.)
python, а в False если
нет:
>>> ‘foo32’.isidentifier()
True
>>> ’32foo’.isidentifier()
False
>>> ‘foo$32’.isidentifier()
False
#Важно: .isidentifier() вернет True для строки,
которая соответствует зарезервированному
ключевому слову python, даже если его
нельзя использовать:
>>> ‘and’.isidentifier()
True
string.islower()
определяет, являются
ли буквенные символы
строки строчными.
возвращает True, если
строка s не пустая, и
все содержащиеся в
нем буквенные
символы строчные, а
False если нет.
Неалфавитные
символы
игнорируются:
>>> ‘abc’.islower()
True
>>> ‘abc1$d’.islower()
True
>>> ‘Abc1$D’.islower()
False
string.isprintable()
определяет, состоит ли
строка только из
печатаемых символов.
возвращает, True если
строка s пустая или все
буквенные символы
которые она содержит
можно вывести на экран.
Возвращает, False если s
содержит хотя бы один
специальный символ. Не
алфавитные символы
игнорируются:
>>> ‘a\tb’.isprintable() # \t — символ
табуляции
False
>>> ‘a b’.isprintable()
True
>>> ‘ ‘.isprintable()
True
>>> ‘a\nb’.isprintable() # \n символ перевода строки
False
string.isspace()
определяет, состоит ли
строка только из
пробельных символов.
возвращает True, если s
не пустая строка, и все
символы являются
пробельными, а False,
если нет.
>>> ‘This Is A Title’.istitle()
True
>>> ‘This is a title’.istitle()
False
>>> ‘Give Me The #$#@
Ball!’.istitle()
True
string.istitle()
определяет, начинаются
ли слова строки с
заглавной буквы.
возвращает True когда s
не пустая строка и первый
алфавитный символ
каждого слова в верхнем
регистре, а все остальные
буквенные символы в
каждом слове строчные.
Возвращает False, если
нет:
>>> ‘ \t \n ‘.isspace()
True
>>> ‘ a ‘.isspace()
False
#Тем не менее есть несколько символов ASCII,
которые считаются пробелами. И если учитывать
символы Юникода, их еще больше:
>>> ‘\f\u2005\r’.isspace()
True
#’\f’ и ‘\r’ являются escape-
последовательностями для символов ASCII;
‘\u2005’ это escape-последовательность для
Unicode.
Выравнивание строк,
отступы
Методы в этой группе влияют на вывод строки.
string.center(
h>[, ])
>>> ‘py’.center(10)
‘ py ‘
выравнивает строку по
центру.
#Если указан необязательный аргумент
, он используется как символ
заполнения:
Возвращает строку,
состоящую из s
выровненной по ширине
. По умолчанию
отступ состоит из пробела
ASCII:
>>> ‘py’.center(10, ‘-‘)
‘—-py—-‘
#Если s больше или равна ,
строка возвращается без изменений:
>>> ‘python’.center(2)
‘python’
string.lstrip([
s>])
обрезает пробельные
символы слева.
Возвращает копию s в
которой все пробельные
символы с левого края
удалены:
>>> ‘ foo bar baz ‘.lstrip()
‘foo bar baz ‘
>>> ‘\t\nfoo\t\nbar\t\nbaz’.lstrip()
‘foo\t\nbar\t\nbaz’
#Необязательный аргумент ,
определяет набор символов, которые
будут удалены:
>>>’https://www.pythonru.com’.lstrip(‘/:pths’)
‘www. pythonru.com’
string.replace(
>, [,
])
>>> ‘I hate python! I hate python! I hate
python!’.replace(‘hate’, ‘love’)
заменяет вхождения
подстроки в строке.
#Если указан необязательный аргумент
, выполняется количество
замен:
Возвращает копию s где
все вхождения подстроки
, заменены на :
>>> ‘I hate python! I hate python! I hate
python!’.replace(‘hate’, ‘love’, 2)
‘I love python! I love python! I love python!’
‘I love python! I love python! I hate python!’
string.rjust(
[, ])
выравнивание по
правому краю строки в
поле.
возвращает строку s,
выравненную по
правому краю в поле
шириной . По
умолчанию отступ
состоит из пробела
ASCII:
>>> ‘python’.rjust(10)
‘ python’
#Если указан аргумент , он
используется как символ заполнения:
>>> ‘python’.rjust(10, ‘-‘)
‘—-python’
#Если s больше или равна , строка
возвращается без изменений:
>>> ‘python’. rjust(2)
‘python’
string.rstrip([
s>])
обрезает пробельные
символы справа
Возвращает копию s
без пробельных
символов, удаленных с
правого края:
>>> ‘ foo bar baz ‘.rstrip()
‘ foo bar baz’
>>> ‘foo\t\nbar\t\nbaz\t\n’.rstrip()
‘foo\t\nbar\t\nbaz’
#Необязательный аргумент ,
определяет набор символов,
которые будут удалены:
>>> ‘foo.$$$;’.rstrip(‘;$.’)
‘foo’
string.strip([
>])
удаляет символы с
левого и правого края
строки.
Эквивалентно
последовательному
вызову s.lstrip()и
s.rstrip(). Без аргумента
метод удаляет
пробелы в начале и в
конце:
>>> s = ‘ foo bar baz\t\t\t’
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
‘foo bar baz’
Важно: Когда возвращаемое значение метода
является другой строкой, как это часто бывает,
методы можно вызывать последовательно:
>>> ‘ foo bar baz\t\t\t’. lstrip().rstrip()
‘foo bar baz’
>>> ‘ foo bar baz\t\t\t’.strip()
‘foo bar baz’
>>>’www.pythonru.com’.lstrip(‘w.’).rstrip(‘.
moc’)
‘pythonru’
>>>’www.pythonru.com’.strip(‘w.moc’)
‘pythonru’
string.zfill()
>>> ’42’.zfill(5)
‘00042’
дополняет строку
нулями слева.
#Если s содержит знак перед цифрами, он
остается слева строки:
Возвращает копию s
дополненную ‘0’ слева
для достижения длины
строки указанной в
:
>>> ‘+42’.zfill(8)
‘+0000042’
>>> ‘-42’.zfill(8)
‘-0000042’
#Если s больше или равна , строка
возвращается без изменений:
>>> ‘-42’.zfill(3)
‘-42’
.zfill() наиболее полезен для строковых представлений
чисел, но python с удовольствием заполнит строку
нулями, даже если в ней нет чисел:
>>> ‘foo’.zfill(6)
‘000foo’
Методы преобразование
строки в список
Методы в этой группе преобразовывают строку в
другой тип данных и наоборот.
Многие из этих методов возвращают либо список,
либо кортеж.
Список заключен в квадратные скобки ( [ ] ), а кортеж
заключен в простые ( ( ) ).
string.join()
объединяет список в
строку.
Возвращает строку,
которая является
результатом
конкатенации объекта
с
разделителем s.
# .join() вызывается строка-разделитель s .
должна быть последовательностью
строковых объектов.
>>> ‘, ‘.join([‘foo’, ‘bar’, ‘baz’, ‘qux’])
‘foo, bar, baz, qux’
# В результате получается одна строка,
состоящая из списка объектов, разделенных
запятыми.
>>> list(‘corge’)
[‘c’, ‘o’, ‘r’, ‘g’, ‘e’]
>>> ‘:’.join(‘corge’)
‘c:o:r:g:e’
string.partition()
делит строку на основе
разделителя.
Отделяет от s
подстроку длиной от
начала до первого
вхождения .
Возвращаемое
значение представляет
собой кортеж из трех
частей:
>>> ‘foo. bar’.partition(‘.’)
(‘foo’, ‘.’, ‘bar’)
>>> ‘[email protected]@[email protected]@baz’.partition(‘@@’)
(‘foo’, ‘@@’, ‘[email protected]@baz’)
#Если не найден в s,
возвращаемый кортеж содержит s и
две пустые строки:
>>> ‘foo.bar’.partition(‘@@’)
(‘foo.bar’, », »)
s.rpartition()
делит строку на основе
разделителя, начиная с
конца.
Работает как
s.partition(), за
исключением того, что
s делится при
последнем вхождении
вместо первого:
>>> ‘[email protected]@[email protected]@baz’.partition(‘@@’)
(‘foo’, ‘@@’, ‘[email protected]@baz’)
>>> ‘[email protected]@[email protected]@baz’.rpartition(‘@@’)
(‘[email protected]@bar’, ‘@@’, ‘baz’)
string.rsplit(sep=None,
maxsplit=-1)
делит строку на список
из подстрок.
Без аргументов делит s
на подстроки,
разделенные любой
последовательностью
пробелов, и возвращает
список:
>>> ‘foo bar baz qux’. rsplit()
[‘foo’, ‘bar’, ‘baz’, ‘qux’]
>>> ‘foo\n\tbar baz\r\fqux’.rsplit()
[‘foo’, ‘bar’, ‘baz’, ‘qux’]
#Если указан, он используется
в качестве разделителя:
>>> ‘foo.bar.baz.qux’.rsplit(sep=’.’)
[‘foo’, ‘bar’, ‘baz’, ‘qux’]
string.rsplit(sep=None, maxsplit=-1)
Если = None, строка разделяется пробелами, как если бы не
был указан вообще.
Когда явно указан в качестве разделителя s, последовательные
повторы разделителя будут возвращены как пустые строки:
>>> ‘foo…bar’.rsplit(sep=’.’)
[‘foo’, », », ‘bar’]
string.rsplit(sep=None, maxsplit=-1)
Если указан необязательный параметр ,
выполняется максимальное количество разделений,
начиная с правого края s:
>>> ‘www.pythonru.com’.rsplit(sep=’.’, maxsplit=1)
[‘www.pythonru’, ‘com’]
string.rsplit(sep=None, maxsplit=-1)
Значение по умолчанию для — -1. Это значит, что все
возможные разделения должны быть выполнены:
>>> ‘www. pythonru.com’.rsplit(sep=’.’, maxsplit=-1)
[‘www’, ‘pythonru’, ‘com’]
>>> ‘www.pythonru.com’.rsplit(sep=’.’)
[‘www’, ‘pythonru’, ‘com’]
string.splitlines([
ends>])
делит текст на список
строк.
Любой из следующих
символов или
последовательностей
символов считается
границей строки:
\n, \r, \r\n,\v,\x0b,\f, \x0c,
\x1c,\x1d,\x1e, \x85,
\u2028, \u2029
>>>
‘foo\nbar\r\nbaz\fqux\u2028quux’.splitlines()
[‘foo’, ‘bar’, ‘baz’, ‘qux’, ‘quux’]
#Если в строке присутствуют последовательные
символы границы строки, они появятся в списке
результатов, как пустые строки:
>>> ‘foo\f\f\fbar’.splitlines()
[‘foo’, », », ‘bar’]
string.splitlines([])
Если необязательный аргумент указан и его булевое значение
True, то символы границы строк сохраняются в списке подстрок:
>>> ‘foo\nbar\nbaz\nqux’.splitlines(True)
[‘foo\n’, ‘bar\n’, ‘baz\n’, ‘qux’]
>>\> ‘foo\nbar\nbaz\nqux’. splitlines(8)
[‘foo\n’, ‘bar\n’, ‘baz\n’, ‘qux’]
Заключение
Было подробно рассмотрено множество различных механизмов, которые
Python предоставляет для работы со строками, включая операторы,
встроенные функции и встроенные методы.
Рассмотренных стандартных возможностей для работы с текстом
достаточно далеко не всегда. Например, в методах find() и replace()
задается всего одна строка. В реальных задачах такая однозначность
встречается довольно редко, чаще требуется найти или заменить строки,
отвечающие некоторому шаблону.
Такую возможность предоставляют регулярные выражения, работа с
которыми будет рассмотрена далее.

Строки в Python | PyLab

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

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

Python имеет два разных типа строк.

Базовый тип строки (обычные строки) сохраняет текст как последовательность байтов (чисел) с одним байтом на символ. Они должны использоваться только в том случае, если вы знаете, что в вашем тексте будут только значения ASCII. Они очень удобны в использовании, поэтому многие программы просто используют этот тип строки. Их также можно использовать для хранения двоичных данных. Они иногда называются байтовыми строками, что является довольно хорошим описанием того, что они делают.

Строки в Unicode хранят текст внутренне, используя стандарт unicode. Они немного сложнее, потому что вы должны знать «кодировку», в которой текст хранится всякий раз, когда вы читаете текст или сохраняете его. В конечном счете это может сэкономить много времени и избежать путаницы.

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

Обычные строки

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

X = ‘Это строка’
Y = “И это так”.

Если вы хотите включить строку в свой код («строковый литерал»), в котором есть разрывы строк, вы можете использовать тройные кавычки. Кавычки могут быть одинарные или двойные.

x = """This string
 goes over multiple lines.
 So it includes line breaks."""
 
 y = '''This string uses single quotes.
 But it is still multi-line.
 As you might have guessed.'''

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

 
 x = '\n'
 
 
 
 
 y = 'Don\'t worry about quotes'
 
 
 
 z = '\'

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

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

raw_string = r'a raw string may contain unescaped \s in it'

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

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

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

Если вы намереваетесь использовать (или разрешать пользователям использовать) символы не-ASCII в вашей программе, то сохранение строк без указания кодировки вызывает проблемы. Если вы не будете очень осторожны, вы, вероятно, неправильно обработаете текст и исказите ваши данные. Гораздо лучше использовать строки unicode, которые кратко описаны ниже.

Строки Unicode

Как упоминалось выше, «обычные строки» в Python являются байтовыми строками и хранят данные в виде последовательности чисел. Это может быть очень удобно для текста ASCII, но как только вы используете символы, отличные от ASCII, то возникают соответствующие проблемы.

Для хорошего «руководства» по использованию Unicode с Python читайте A Crash Course в кодировках символов.

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

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

Правила цитирования и экранирования для строк в Юникоде такие же, как для строк байтов:

x = u'A unicode string'
 
 y = u'''A multi-line unicode
 string.'''
 
 y = ru"""This is a
 raw, multi-line
 unicode string !!!
 """

Вы можете принудить интерпретатор Python к конвертированию между unicode и byte-strings без указания явной кодировки, но скорее всего это повлечет за собой крах системы. Это может произойти, когда одна из строк, которую вы “неявно” преобразуете, (например, добавив строку юникода в строку байтов) имеет символы, которые не могут быть представлены в кодировке системы по умолчанию (которая обычно будет ASCII).\

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

Другие полезные значения

Есть еще несколько полезных значений, которые могут пригодиться.

None: часто записываемый как null в других языках, обычно используется для представления «ничего».
True:   логическое  значение истина.
False:  логическое  значение ложь.

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

x = None
y = True
z = None

Поделитесь с друзьями:

Основные операции с строками в Python

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

str = ‘Hellow World!’
str = «Hellow World!»
str = «»»Sunday
Monday
Tuesday»»»

Доступ к символам в строке

Чтобы символы доступа из String, используйте квадратные скобки [] для нарезки вместе с индексом или индексами для получения ваших символов. Индекс строки Python начинается с 0.

str = ‘Hellow World!’
print(str [0]) # output is «H»
print(str [7]) # output is «W»
print(str [0:6]) #output is Hellow
print(str [7:12]) #output is World

Python допускает отрицательную индексацию для своих последовательностей.

Индекс -1 относится к последнему элементу, -2 ко второму последнему пункту и так далее.

print(str [0:-6]) # output is Hellow
print(str [7:-1]) # output is World

Объединение строк в Python

Объединение двух или более строк в одну называется конкатенацией. Python использует оператор «+» для объединения одной или нескольких строк

str1 = ‘Hellow ‘
str2 = ‘ World!’
print(str1 + str2)

Вывод:

Reverse a String

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

Нижний индекс создает срез, включая двоеточие в фигурных скобках:

Он работает, выполняя [begin: end: step] — оставив начало и конец и задавая шаг -1, он меняет строку.

str = ‘Python String’
print(str[::-1])

Вывод:

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

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

Длина строки len() в Python

Метод String len() возвращает длину строки.

str = «Hellow World!»
print(len(str))

Вывод:

Метод Count() для подсчета подстрок в строке в Python

Метод String count () возвращает количество вхождений подстроки в данной строке.

str = «Python is Object Oriented»
substr = «Object»
print(str.count(substr))

Вывод:

Метод Index() индекса подстроки в строке в Python

Метод String index() возвращает индекс подстроки внутри данной строки.

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

str = «Python is Object Oriented»
substr = «is»
print(str.index(substr))

Вывод:

Преобразование букв в верхний регистр в Python

String upper() преобразует данную строку в буквы верхнего регистра и возвращает новую строку.

str = «Python is Object Oriented»
print(str.upper())

Вывод:

PYTHON IS OBJECT ORIENTED

Преобразование букв в нижний регистр в Python

Строка lower () преобразует данную строку в строчные буквы и возвращает новую строку.

str = «Python is Object Oriented»
print(str.lower())

Вывод:

python is object oriented

Метод startswith() в Python

Метод String startswith() возвращает Boolean TRUE, если строка начинается с указанной подстроки в противном случае, она вернет False.

str = «Python is Object Oriented»
print(str.startswith(«Python»))
print(str.startswith(«Object»))

Вывод:

Метод endswith() в Python

Метод String endswith() возвращает Boolean TRUE, если строка заканчивается с указанной подстрокой в ​​противном случае возвращает False.

str = «Python is Object Oriented»
print(str.endswith(«Oriented»))
print(str.endswith(«Object»))

Вывод:

Разбиение строки на более мелкие Split()

Метод String split () разбивает строку на более мелкие строки на основе разделителя или символа.

str = ‘Python is Object Oriented’
print(str.split())

Вывод:

[‘Python’, ‘is’, ‘Object’, ‘Oriented’]

Пример:

str = ‘Python,is,Object,Oriented’
print(str.split(‘,’))

Вывод:

[‘Python’, ‘is’, ‘Object’, ‘Oriented’]

Пример:

str = ‘Python,is,Object,Oriented’
print(str.split(‘,’,2))

Вывод:

[‘Python’, ‘is’, ‘Object,Oriented’]

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

str = ‘Python,is,Object,Oriented’
sList = str.split(‘,’)
for temp in sList:
print (temp)

Вывод:

Python
is
Object
Oriented

Метод join() Python String

String join() — это строковый метод, который возвращает строку, конкатенированную с элементами итерабельного.

str = «Python is Object Oriented»
tmp = «-«
print (tmp.join(str))

Вывод:

P-y-t-h-o-n- -i-s- -O-b-j-e-c-t- -O-r-i-e-n-t-e-d

Метод find() индекс первого вхождения строки в Python

String find () возвращает индексную позицию первого вхождения указанной строки. Он вернет -1, если указанная строка не найдена.

str = «Python is Object Oriented»
st = «Object»
print (str.find(st))
print (str.find(st,20)) #finding from 20th position

Вывод:

Метод strip() удаление символов из строки в Python

String strip() удаляет указанные символы как с правой стороны, так и с левой стороны строки (по умолчанию, белые пробелы) и возвращает новую строку.

str = » Python is Object Oriented «
print (str.strip())

Вывод:

Python is Object Oriented

Метод rstrip() копировать строку с удаленными символами

Строка rstrip () возвращает копию строки с удаленными символами.

str = » Python is Object Oriented «
print (str.rstrip())

Вывод:

Python is Object Oriented

Метод lstrip()

Строка lstrip () возвращает копию строки с удаленными ведущими символами.

str = » Python is Object Oriented «
print (str.lstrip())

Вывод:

Python is Object Oriented

Источник: net-informations.com

Строки и символьные данные в Python — Real Python

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

Строковые операторы

Вы уже видели, как операторы + и * применялись к числовым операндам в учебнике по операторам и выражениям в Python. Эти два оператора также могут применяться к строкам.

+ Оператор

Оператор + объединяет строки.Он возвращает строку, состоящую из операндов, объединенных вместе, как показано здесь:

>>>

  >>> s = 'foo'
>>> t = 'бар'
>>> u = 'baz'

>>> с + т
'foobar'
>>> с + т + и
'foobarbaz'

>>> print ('Go team' + '!!!')
Вперед, команда !!!
  

Оператор

*

Оператор * создает несколько копий строки. Если s — это строка, а n — целое число, любое из следующих выражений возвращает строку, состоящую из n конкатенированных копий s :

с * с
н * с

Вот примеры обеих форм:

>>>

  >>> s = 'foo.'

>>> с * 4
'foo.foo.foo.foo.'
>>> 4 * с
'foo.foo.foo.foo.'
  

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

Если бы вы создали строковую переменную и инициализировали ее пустой строкой, присвоив ей значение 'foo' * -8 , любой справедливо подумал бы, что вы немного глупы. Но это сработает.

в Оператор

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

>>>

  >>> s = 'foo'

>>> в 'Это пища для размышлений'.
Истинный
>>> в "Пока хорошо".
Ложь
  

Также есть оператор не в , который делает наоборот:

>>>

  >>> 'z' не входит в 'abc'
Истинный
>>> 'z' не входит в 'xyz'
Ложь
  

Встроенные строковые функции

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

Более подробно они рассматриваются ниже.

орд (в)

Возвращает целое число для данного символа.

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

Самая простая из распространенных схем называется ASCII. Он охватывает распространенные латинские символы, с которыми вы, вероятно, привыкли работать. Для этих символов ord (c) возвращает значение ASCII для символа c :

>>>

  >>> ord ('а')
97
>>> ord ('#')
35 год
  

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

Unicode — амбициозный стандарт, который пытается предоставить числовой код для каждого возможного символа на всех возможных языках и на всех возможных платформах. Python 3 широко поддерживает Юникод, в том числе позволяет использовать символы Юникода в строках.

Пока вы остаетесь в домене общих символов, между ASCII и Unicode мало практических различий. Но функция ord () также вернет числовые значения для символов Юникода:

>>>

  >>> ord ('€')
8364
>>> ord ('∑')
8721
  

chr (п)

Возвращает символьное значение для заданного целого числа.

chr () выполняет обратную операцию ord () .Учитывая числовое значение n , chr (n) возвращает строку, представляющую символ, который соответствует n :

>>>

  >>> chr (97)
'а'
>>> chr (35)
'#'
  

chr () также обрабатывает символы Unicode:

>>>

  >>> chr (8364)
'€'
>>> chr (8721)
'∑'
  

лин (-ы)

Возвращает длину строки.

С помощью len () вы можете проверить длину строки Python. len (s) возвращает количество символов за с :

>>>

  >>> s = 'Я строка.'
>>> len (s)
14
  

ул (объект)

Возвращает строковое представление объекта.

Практически любой объект в Python может быть отображен в виде строки. str (obj) возвращает строковое представление объекта obj :

>>>

  >>> str (49.2)
'49.2 '
>>> str (3 + 4j)
'(3 + 4j)'
>>> ул (3 + 29)
'32'
>>> str ('фу')
'фу'
  

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

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

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

Индексирование строк в Python начинается с нуля: первый символ в строке имеет индекс 0 , следующий — индекс 1 и т. Д. Индекс последнего символа будет длиной строки минус один.

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

Строковые индексы

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

>>>

  >>> s = 'foobar'

>>> s [0]
'f'
>>> s [1]
'о'
>>> s [3]
'b'
>>> len (s)
6
>>> s [len (s) -1]
'р'
  

Попытка индексировать за пределами конца строки приводит к ошибке:

>>>

  >>> s [6]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    s [6]
IndexError: индекс строки вне допустимого диапазона
  

Индексы строки также могут быть указаны с отрицательными числами, и в этом случае индексация выполняется с конца строки назад: -1 относится к последнему символу, -2 — к предпоследнему символу и т. Д.Вот та же диаграмма, показывающая как положительные, так и отрицательные индексы в строке 'foobar' :

.
Положительные и отрицательные строковые индексы

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

>>>

  >>> s = 'foobar'

>>> s [-1]
'р'
>>> с [-2]
'а'
>>> len (s)
6
>>> s [-len (s)]
'f'
  

Попытка индексирования с отрицательными числами за пределами начала строки приводит к ошибке:

>>>

  >>> с [-7]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    с [-7]
IndexError: индекс строки вне допустимого диапазона
  

Для любой непустой строки с , с [лен (с) -1] и с [-1] оба возвращают последний символ.Нет никакого индекса, который имел бы смысл для пустой строки.

Нарезка струн

Python также позволяет использовать синтаксис индексации, который извлекает подстроки из строки, известный как нарезка строки. Если s является строкой, выражение вида s [m: n] возвращает часть s , начиная с позиции m и вплоть до позиции n :

, но не включая
>>>

  >>> s = 'foobar'
>>> s [2: 5]
'оба'
  

Помните: Строковые индексы отсчитываются от нуля.Первый символ в строке имеет индекс 0 . Это относится как к стандартной индексации, так и к нарезке.

Опять же, второй индекс определяет первый символ, который не включен в результат — символ 'r' ( s [5] ) в приведенном выше примере. Это может показаться немного неинтуитивным, но дает такой результат, который имеет смысл: выражение s [m: n] вернет подстроку длиной n - m символов, в данном случае 5 - 2 = 3 .

Если вы опустите первый индекс, срез начнется в начале строки. Таким образом, s [: m] и s [0: m] эквивалентны:

>>>

  >>> s = 'foobar'

>>> s [: 4]
'фуб'
>>> s [0: 4]
'фуб'
  

Аналогично, если вы опустите второй индекс, как в s [n:] , срез простирается от первого индекса до конца строки. Это хорошая и лаконичная альтернатива более громоздкому s [n: len (s)] :

>>>

  >>> s = 'foobar'

>>> s [2:]
'обар'
>>> s [2: len (s)]
'обар'
  

Для любой строки s и любого целого n ( 0 ≤ n ≤ len (s) ) s [: n] + s [n:] будет равно s :

>>>

  >>> s = 'foobar'

>>> s [: 4] + s [4:]
'foobar'
>>> s [: 4] + s [4:] == s
Истинный
  

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

>>>

  >>> s = 'foobar'
>>> t = s [:]
>>> id (s)
59598496
>>> id (t)
59598496
>>> s is t
Истинный
  

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

>>>

  >>> s [2: 2]
''
>>> s [4: 2]
''
  

Отрицательные индексы также могут использоваться с нарезкой.–1 относится к последнему символу, –2 — предпоследнему и т. Д., Как и при простой индексации. На диаграмме ниже показано, как вырезать подстроку 'oob' из строки 'foobar' , используя как положительные, так и отрицательные индексы:

Нарезка строки с положительными и отрицательными индексами

Вот соответствующий код Python:

>>>

  >>> s = 'foobar'

>>> s [-5: -2]
'oob'
>>> s [1: 4]
'oob'
>>> s [-5: -2] == s [1: 4]
Истинный
  

Указание шага в срезе строки

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

Например, для строки 'foobar' срез 0: 6: 2 начинается с первого символа и заканчивается последним символом (всей строкой), и каждый второй символ пропускается. Это показано на следующей диаграмме:

Индексирование строки с помощью Stride

Аналогично, 1: 6: 2 задает срез, начинающийся со второго символа (индекс 1 ) и заканчивающийся последним символом, и снова значение шага 2 заставляет пропускать все остальные символы. :

Другая строковая индексация с помощью Stride

Пример кода REPL показан здесь:

>>>

  >>> s = 'foobar'

>>> s [0: 6: 2]
'foa'

>>> s [1: 6: 2]
'obr'
  

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

>>>

  >>> s = '12345' * 5
>>> с
'1234512345123451234512345'
>>> s [:: 5]
'11111'
>>> s [4 :: 5]
'55555'
  

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

>>>

  >>> s = 'foobar'
>>> s [5: 0: -2]
'rbo'
  

В приведенном выше примере 5: 0: -2 означает «начать с последнего символа и сделать шаг назад на 2 , вплоть до первого символа, но не включая его».

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

>>>

  >>> s = '12345' * 5
>>> с
'1234512345123451234512345'
>>> s [:: - 5]
'55555'
  

Это обычная парадигма переворачивания строки:

>>>

  >>> s = 'Если товарищ Наполеон так говорит, значит, это правильно'.
>>> s [:: - 1]
'.thgir eb tsum ti, ti syas noelopaN edarmoC fI'
  

Интерполяция переменных в строку

В версии Python 3.6 был представлен новый механизм форматирования строк.Эта функция официально называется литералом форматированной строки, но чаще упоминается по псевдониму f-string .

Возможности форматирования, предоставляемые f-строками, обширны и не будут здесь подробно рассматриваться. Если вы хотите узнать больше, вы можете ознакомиться со статьей Real Python «f-строки Python 3: улучшенный синтаксис форматирования строк» ​​(руководство). Позже в этой серии вы найдете учебное пособие по форматированному выводу, в котором более подробно рассматриваются f-строки.

Одна простая функция f-струн, которую вы можете сразу начать использовать, — это интерполяция переменных.Вы можете указать имя переменной непосредственно в литерале f-строки, и Python заменит имя соответствующим значением.

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

>>>

  >>> п = 20
>>> m = 25
>>> prod = n * m
>>> print ('Произведение', n, 'и', m, 'is', prod)
Произведение 20 и 25 равно 500.
  

Но это громоздко.Чтобы сделать то же самое, используя f-строку:

• Укажите строчные f или прописные F непосредственно перед открывающей кавычкой строкового литерала. Это говорит Python, что это f-строка, а не стандартная строка.
• Укажите любые переменные для интерполяции в фигурных скобках ( {} ).

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

>>>

  >>> п = 20
>>> m = 25
>>> prod = n * m
>>> print (f'Произведение {n} и {m} равно {prod} ')
Произведение 20 и 25 равно 500.
  

Для определения f-строки можно использовать любой из трех механизмов цитирования Python:

>>>

  >>> var = 'Кора'

>>> print (f'A dog говорит {var}! ')
Собака говорит Лай!
>>> print (f "Собака говорит {var}!")
Собака говорит Лай!
>>> print (f '' 'Собака говорит {var}!' '')
Собака говорит Лай!
  

Изменение строк

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

Подобная инструкция вызовет ошибку:

>>>

  >>> s = 'foobar'
>>> s [3] = 'x'
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    s [3] = 'x'
TypeError: объект 'str' не поддерживает назначение элементов
  

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

>>>

  >>> s = s [: 3] + 'x' + s [4:]
>>> с
'fooxar'
  

Для этого существует также встроенный строковый метод:

>>>

  >>> s = 'foobar'
>>> s = s.replace ('б', 'х')
>>> с
'fooxar'
  

Прочтите, чтобы узнать больше о встроенных строковых методах!

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

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

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

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

Синтаксис вызова метода для объекта следующий:

Это вызывает метод .foo () для объекта obj . указывает аргументы, передаваемые методу (если есть).

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

В следующих определениях методов аргументы, указанные в квадратных скобках ( [] ), необязательны.

Преобразование корпуса

Методы этой группы выполняют преобразование регистра в целевой строке.

s.capitalize ()

Делает целевую строку с заглавной буквы.

s.capitalize () возвращает копию s с первым символом, преобразованным в верхний регистр, а все остальные символы преобразованы в нижний регистр:

>>>

  >>> s = 'foO BaR BAZ quX'
>>> s.capitalize ()
'Foo bar baz qux'
  

Неалфавитные символы без изменений:

>>>

  >>> s = 'foo123 # BAR #.'
>>> s.capitalize ()
'Foo123 # bar #.'
  

с. Нижний ()

Преобразует буквенные символы в нижний регистр.

s.lower () возвращает копию s со всеми буквенными символами, преобразованными в нижний регистр:

>>>

  >>> 'FOO Bar 123 baz qUX'.lower ()
'foo bar 123 baz qux'
  

s.swapcase ()

Меняет местами регистр буквенных символов.

с.swapcase () возвращает копию s с буквенными символами верхнего регистра, преобразованными в нижний регистр и наоборот:

>>>

  >>> 'FOO Bar 123 baz qUX'.swapcase ()
'foo bAR 123 BAZ Qux'
  

название ()

Преобразует целевую строку в «регистр заголовка».

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

>>>

  >>> 'солнце тоже встает'.заглавие()
"И солнце восходит"
  

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

>>>

  >>> «Что случилось с акциями IBM Теда?». Title ()
"Что случилось с Ibm Stock Теда?"
  

с. Верх. ()

Преобразует буквенные символы в верхний регистр.

с.upper () возвращает копию s со всеми буквенными символами, преобразованными в верхний регистр:

>>>

  >>> 'FOO Bar 123 baz qUX'.upper ()
'FOO BAR 123 BAZ QUX'
  

Найти и заменить

Эти методы предоставляют различные средства поиска указанной подстроки в целевой строке.

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

s.count ( [, [, ]])

Подсчитывает количество вхождений подстроки в целевой строке.

s.count () возвращает количество неперекрывающихся вхождений подстроки за с :

>>>

  >>> 'foo goo moo'.count ('oo')
3
  

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

>>>

  >>> 'foo goo moo'.count (' oo ', 0, 8)
2
  

s.endswith (<суффикс> [, <начало> [, <конец>]])

Определяет, заканчивается ли целевая строка заданной подстрокой.

s.endswith () возвращает True , если s заканчивается указанным и False в противном случае:

>>>

  >>> 'foobar'.заканчивается ('бар')
Истинный
>>> 'foobar'.endswith (' баз ')
Ложь
  

Сравнение ограничено подстрокой, указанной как и , если они указаны:

>>>

  >>> 'foobar'.endswith (' oob ', 0, 4)
Истинный
>>> 'foobar'.endswith (' oob ', 2, 4)
Ложь
  

s.find ( [, [, ]])

Ищет заданную подстроку в целевой строке.

Вы можете использовать .find () , чтобы узнать, содержит ли строка Python определенную подстроку. s.find () возвращает самый низкий индекс за s , где найдена подстрока :

>>>

  >>> 'foo bar foo baz foo qux'.find (' foo ')
0
  

Этот метод возвращает -1 , если указанная подстрока не найдена:

>>>

  >>> 'foo bar foo baz foo qux'.найти ('граулт')
-1
  

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

>>>

  >>> 'foo bar foo baz foo qux'.find (' foo ', 4)
8
>>> 'фу бар фу баз фу qux'.find (' фу ', 4, 7)
-1
  

s.index ( [, [, ]])

Ищет заданную подстроку в целевой строке.

Этот метод идентичен .find () , за исключением того, что он вызывает исключение, если не найден, а не возвращает -1 :

>>>

  >>> 'foo bar foo baz foo qux'.index (' grault ')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    'foo bar foo baz foo qux'.index (' grault ')
ValueError: подстрока не найдена
  

s.rfind ( [, [, ]])

Ищет в целевой строке заданную подстроку, начиная с конца.

s.rfind () возвращает наивысший индекс за s , где найдена подстрока :

>>>

  >>> 'foo bar foo baz foo qux'.rfind (' foo ')
16
  

Как и в случае с .find () , если подстрока не найдена, возвращается -1 :

>>>

  >>> 'foo bar foo baz foo qux'.rfind (' grault ')
-1
  

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

>>>

  >>> 'foo bar foo baz foo qux'.rfind ('фу', 0, 14)
8
>>> 'фу бар фу баз фу qux'.rfind (' фу ', 10, 14)
-1
  

s.rindex ( [, [, ]])

Ищет в целевой строке заданную подстроку, начиная с конца.

Этот метод идентичен .rfind () , за исключением того, что он вызывает исключение, если не найден, а не возвращает -1 :

>>>

  >>> 'foo bar foo baz foo qux'.rindex ('граулт')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    'foo bar foo baz foo qux'.rindex (' граулт ')
ValueError: подстрока не найдена
  

с. Начинается с (<префикс> [, <начало> [, <конец>]])

Определяет, начинается ли целевая строка с данной подстроки.

При использовании метода Python .startswith () s.startswith () возвращает True , если s начинается с указанного и False в противном случае:

>>>

  >>> 'foobar'.начинается с ('фу')
Истинный
>>> 'foobar'.startswith (' бар ')
Ложь
  

Сравнение ограничено подстрокой, указанной как и , если они указаны:

>>>

  >>> 'foobar'.startswith (' bar ', 3)
Истинный
>>> 'foobar'.startswith (' бар ', 3, 2)
Ложь
  

Классификация символов

Методы этой группы классифицируют строку на основе содержащихся в ней символов.

s.isalnum ()

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

s.isalnum () возвращает True , если s непусто и все его символы являются буквенно-цифровыми (буква или число), а False в противном случае:

>>>

  >>> 'abc123'.isalnum ()
Истинный
>>> 'abc $ 123'.isalnum ()
Ложь
>>> '' .isalnum ()
Ложь
  

с.isalpha ()

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

s.isalpha () возвращает True , если s непусто и все его символы буквенные, и False в противном случае:

>>>

  >>> 'ABCabc'.isalpha ()
Истинный
>>> 'abc123'.isalpha ()
Ложь
  

s.isdigit ()

Определяет, состоит ли целевая строка из цифровых символов.

Вы можете использовать метод Python .isdigit () , чтобы проверить, состоит ли ваша строка только из цифр. s.isdigit () возвращает True , если s непусто и все его символы являются числовыми цифрами, и False в противном случае:

>>>

  >>> '123'.isdigit ()
Истинный
>>> '123abc'.isdigit ()
Ложь
  

s.isidentifier ()

Определяет, является ли целевая строка допустимым идентификатором Python.

s.isidentifier () возвращает True , если s является допустимым идентификатором Python в соответствии с определением языка, и False в противном случае:

>>>

  >>> 'foo32'.isidentifier ()
Истинный
>>> '32foo'.isidentifier ()
Ложь
>>> 'foo $ 32'.isidentifier ()
Ложь
  

Примечание: .isidentifier () вернет True для строки, которая соответствует ключевому слову Python, даже если на самом деле это не будет действительным идентификатором:

>>>

  >>> 'и'.isidentifier ()
Истинный
  

Вы можете проверить, соответствует ли строка ключевому слову Python, используя функцию iskeyword () , которая содержится в модуле keyword . Один из возможных способов сделать это показан ниже:

>>>

  >>> from keyword import iskeyword
>>> iskeyword ('и')
Истинный
  

Если вы действительно хотите убедиться, что строка будет служить допустимым идентификатором Python, вам следует проверить, что .isidentifier () — это True , а iskeyword () — False .

См. Модули и пакеты Python — Введение, чтобы узнать больше о модулях Python.

с. Ниже ()

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

s.islower () возвращает True , если s непусто и все содержащиеся в нем буквенные символы строчные, а False в противном случае.Неалфавитные символы игнорируются:

>>>

  >>> 'abc'.islower ()
Истинный
>>> 'abc1 $ d'.islower ()
Истинный
>>> 'Abc1 $ D'.islower ()
Ложь
  

s. Печатная ()

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

s.isprintable () возвращает True , если s пусто или все содержащиеся в нем буквенные символы можно распечатать.Он возвращает False , если s содержит хотя бы один непечатаемый символ. Неалфавитные символы игнорируются:

>>>

  >>> 'a \ tb'.isprintable ()
Ложь
>>> 'a b'.isprintable ()
Истинный
>>> '' .isprintable ()
Истинный
>>> 'a \ nb'.isprintable ()
Ложь
  

Примечание: Это единственный метод .isxxxx () , который возвращает True , если s — пустая строка. Все остальные возвращают Ложь для пустой строки.

s.isspace ()

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

s.isspace () возвращает True , если s непусто и все символы являются пробельными символами, и False в противном случае.

Наиболее часто встречающиеся пробельные символы — это пробел '' , табуляция '\ t' и новая строка '\ n' :

>>>

  >>> '\ t \ n'.isspace ()
Истинный
>>> 'а' .isspace ()
Ложь
  

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

>>>

  >>> '\ f \ u2005 \ r'.isspace ()
Истинный
  

( '\ f' и '\ r' — это escape-последовательности для символов подачи формы ASCII и возврата каретки; '\ u2005' — это escape-последовательность для Unicode Four-Per-Em Space.)

с. Наименование ()

Определяет, имеет ли целевая строка регистр заголовка.

s.istitle () возвращает True , если s не пусто, первый буквенный символ каждого слова — заглавные, а все остальные буквенные символы в каждом слове — строчные. Возвращает Ложь в противном случае:

>>>

  >>> 'This Is A Title'. Название ()
Истинный
>>> 'Это заголовок'.istitle ()
Ложь
>>> «Дайте мне # $ # @ Ball!».istitle ()
Истинный
  

Примечание: Вот как документация Python описывает .istitle () , на случай, если вы сочтете это более интуитивным: «Заглавные символы могут следовать только за символами без регистра, а за символами в нижнем регистре — только за ними».

с. Верхняя ()

Определяет, являются ли буквенные символы целевой строки прописными.

s.isupper () возвращает True , если s непусто и все содержащиеся в нем буквенные символы прописные, а False в противном случае.Неалфавитные символы игнорируются:

>>>

  >>> 'ABC'.isupper ()
Истинный
>>> 'ABC1 $ D'.isupper ()
Истинный
>>> 'Abc1 $ D'.isupper ()
Ложь
  

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

Методы этой группы изменяют или улучшают формат строки.

s.center ( [, ])

Центрирует строку в поле.

s.center () возвращает строку, состоящую из s с центром в поле шириной .По умолчанию заполнение состоит из символа пробела ASCII:

.
>>>

  >>> 'foo'.center (10)
'фу'
  

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

>>>

  >>> 'bar'.center (10,' - ')
'---бар----'
  

Если с уже не меньше <ширина> , оно возвращается без изменений:

>>>

  >>> 'фу'.центр (2)
'фу'
  

s.expandtabs (tabsize = 8)

Раскрывает табуляции в строке.

s.expandtabs () заменяет каждый символ табуляции ( '\ t' ) пробелами. По умолчанию пробелы заполняются с учетом позиции табуляции в каждом восьмом столбце:

>>>

  >>> 'a \ tb \ tc'.expandtabs ()
'а б в'
>>> 'aaa \ tbbb \ tc'.expandtabs ()
'aaa bbb c'
  

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

>>>

  >>> 'а \ tb \ tc'.expandtabs (4)
'а б в'
>>> 'aaa \ tbbb \ tc'.expandtabs (tabsize = 4)
'aaa bbb c'
  

s.ljust (<ширина> [, <заполнить>])

Выравнивает строку в поле по левому краю.

s.ljust () возвращает строку, состоящую из s с выравниванием по левому краю в поле шириной . По умолчанию заполнение состоит из символа пробела ASCII:

.
>>>

  >>> 'foo'.ljust (10)
'фу'
  

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

>>>

  >>> 'фу'.ljust (10, '-')
'фу -------'
  

Если с уже не меньше <ширина> , оно возвращается без изменений:

>>>

  >>> 'foo'.ljust (2)
'фу'
  

s.lstrip ([])

Обрезает начальные символы строки.

s.lstrip () возвращает копию s с удалением любых пробельных символов с левого края:

>>>

  >>> 'foo bar baz'.lstrip ()
'foo bar baz'
>>> '\ t \ nfoo \ t \ nbar \ t \ nbaz'.lstrip ()
'foo \ t \ nbar \ t \ nbaz'
  

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

>>>

  >>> 'http: //www.realpython.com'.lstrip (' /: pth ')
"www.realpython.com"
  

s.replace (, [, ])

Заменяет вхождения подстроки в строке.

В Python для удаления символа из строки можно использовать метод Python string .replace () . s.replace (, ) возвращает копию s со всеми вхождениями подстроки , замененной на :

>>>

  >>> 'foo bar foo baz foo qux'.replace (' foo ',' grault ')
'Grault Bar Grault Baz Grault Qux'
  

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

>>>

  >>> 'foo bar foo baz foo qux'.replace ('фу', 'граулт', 2)
'grault bar grault baz foo qux'
  

s.rjust (<ширина> [, <заполнить>])

Выравнивает строку в поле по правому краю.

s.rjust () возвращает строку, состоящую из s , выровненных по правому краю, в поле шириной . По умолчанию заполнение состоит из символа пробела ASCII:

.
>>>

  >>> 'foo'.rjust (10)
'фу'
  

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

>>>

  >>> 'фу'.rjust (10, '-')
'------- фу'
  

Если с уже не меньше <ширина> , оно возвращается без изменений:

>>>

  >>> 'foo'.rjust (2)
'фу'
  

s.rstrip ([])

Обрезает завершающие символы в строке.

s.rstrip () возвращает копию s с удаленными пробельными символами с правого конца:

>>>

  >>> 'foo bar baz'.rstrip ()
'foo bar baz'
>>> 'foo \ t \ nbar \ t \ nbaz \ t \ n'.rstrip ()
'foo \ t \ nbar \ t \ nbaz'
  

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

>>>

  >>> 'foo. $$$;'. Rstrip ('; $.')
'фу'
  

s.strip ([])

Удаляет символы с левого и правого концов строки.

s.strip () по существу эквивалентен вызову s.lstrip () и s.rstrip () последовательно. Без аргумента он удаляет начальные и конечные пробелы:

>>>

  >>> s = 'foo bar baz \ t \ t \ t'
>>> s = s.lstrip ()
>>> s = s.rstrip ()
>>> с
'foo bar baz'
  

Как и в случае с .lstrip () и .rstrip () , необязательный аргумент указывает набор символов, которые необходимо удалить:

>>>

  >>> 'www.realpython.com'.strip ('w.moc')
'realpython'
  

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

>>>

  >>> 'foo bar baz \ t \ t \ t'.lstrip (). Rstrip ()
'foo bar baz'
>>> 'foo bar baz \ t \ t \ t'.strip ()
'foo bar baz'

>>> 'www.realpython.com'.lstrip (' w.moc '). rstrip (' w.moc ')
'realpython'
>>> 'www.realpython.com'.полоса ('w.moc')
'realpython'
  

s.zfill (<ширина>)

Добавляет нули в строку слева.

s.zfill () возвращает копию s с заполнением слева '0' символов до указанного :

>>>

  >>> '42'.zfill (5)
«00042»
  

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

>>>

  >>> '+42'.zfill (8)
'+0000042'
>>> '-42'.zfill (8)
'-0000042'
  

Если с уже не меньше <ширина> , оно возвращается без изменений:

>>>

  >>> '-42'.zfill (3)
'-42'
  

.zfill () наиболее полезен для строковых представлений чисел, но Python все равно с радостью выполнит нулевое заполнение строки, которой нет:

>>>

  >>> 'foo'.zfill (6)
'000foo'
  

Преобразование между строками и списками

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

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

Многие из этих методов возвращают либо список, либо кортеж. Это два похожих составных типа данных, которые являются прототипами итераций в Python. Они будут рассмотрены в следующем руководстве, так что скоро вы узнаете о них! А пока считайте их просто последовательностями значений.Список заключен в квадратные скобки ( [] ), а кортеж заключен в круглые скобки ( () ).

После этого введения давайте взглянем на последнюю группу строковых методов.

s.join ()

Объединяет строки из итерируемого объекта.

s.join () возвращает строку, полученную в результате объединения объектов в , разделенных s .

Обратите внимание, что .join () вызывается на s , строке-разделителе. также должен быть последовательностью строковых объектов.

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

>>>

  >>> ',' .join (['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'
  

Результат — одна строка, состоящая из объектов списка, разделенных запятыми.

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

>>>

  >>> список ('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'. join ('corge')
'c: o: r: g: e'
  

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

Этот пример не выполняется, потому что один из объектов в не является строкой:

>>>

  >>> '---'. Join (['foo', 23, 'bar'])
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    '---'. join (['foo', 23, 'bar'])
TypeError: элемент последовательности 1: ожидаемый экземпляр str, найдено int
  

Но это можно исправить:

>>>

  >>> '---'. Join (['foo', str (23), 'bar'])
'foo --- 23 --- bar'
  

Как вы вскоре увидите, многие составные объекты в Python могут быть сконструированы как итерируемые объекты, а .join () особенно полезен для создания из них строк.

раздел ()

Делит строку по разделителю.

s.partition () разбивает s при первом появлении строки . Возвращаемое значение представляет собой кортеж из трех частей, состоящий из:

• Часть с , предшествующая
• сам
• Часть с после

Вот пара примеров .partition () в действии:

>>>

  >>> 'foo.bar'.partition ('. ')
('фу', '.', 'бар')
>>> 'foo @@ bar @@ baz'.partition (' @@ ')
('foo', '@@', 'bar @@ baz')
  

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

>>>

  >>> 'foo.bar'.partition (' @@ ')
('foo.bar', '', '')
  

Помните: Списки и кортежи рассматриваются в следующем руководстве.

с.р раздел ()

Делит строку по разделителю.

s.rpartition () функционирует точно так же, как s.partition () , за исключением того, что сек разбивается при последнем появлении вместо первого появления:

>>>

  >>> 'foo @@ bar @@ baz'.partition (' @@ ')
('foo', '@@', 'bar @@ baz')

>>> 'foo @@ bar @@ baz'.rpartition (' @@ ')
('foo @@ bar', '@@', 'baz')
  

с.rsplit (sep = Нет, maxsplit = -1)

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

Без аргументов s.rsplit () разбивает s на подстроки, разделенные любой последовательностью пробелов, и возвращает подстроки в виде списка:

>>>

  >>> 'foo bar baz qux'.rsplit ()
['foo', 'bar', 'baz', 'qux']
>>> 'foo \ n \ tbar baz \ r \ fqux'.rsplit ()
['foo', 'bar', 'baz', 'qux']
  

Если указано , оно используется как разделитель для разделения:

>>>

  >>> 'foo.bar.baz.qux'.rsplit (sep = '.')
['foo', 'bar', 'baz', 'qux']
  

(Если указан со значением None , строка разделяется пробелами, как если бы не было указано вообще.)

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

>>>

  >>> 'foo...bar'.rsplit (sep = '.')
['фу', '', '', 'бар']
  

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

>>>

  >>> 'foo \ t \ t \ tbar'.rsplit ()
['фу', 'бар']
  

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

>>>

  >>> 'www.realpython.com'.rsplit (sep = '.', maxsplit = 1)
['www.realpython', 'com']
  

Значение по умолчанию для — -1 , что означает, что должны быть выполнены все возможные разбиения — так же, как если бы полностью опущено:

>>>

  >>> 'www.realpython.com'.rsplit (sep ='. ', Maxsplit = -1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit (sep ='. ')
['www', 'realpython', 'com']
  

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

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

s.split () ведет себя точно так же, как s.rsplit () , за исключением того, что если указано , разделения отсчитываются с левого конца с , а не с правого конца:

>>>

  >>> 'www.realpython.com'.split ('. ', Maxsplit = 1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit ('. ', maxsplit = 1)
['www.realpython ',' com ']
  

Если не указано, .split () и .rsplit () неотличимы.

s.splitlines ([])

Разрывает строку по границам строки.

s.splitlines () разбивает s на строки и возвращает их в виде списка. Любой из следующих символов или последовательностей символов считается границей строки:

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

>>>

  >>> 'foo \ nbar \ r \ nbaz \ fqux \ u2028quux'.splitlines ()
['foo', 'bar', 'baz', 'qux', 'quux']
  

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

>>>

  >>> 'foo \ f \ f \ fbar'.splitlines ()
['фу', '', '', 'бар']
  

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

>>>

  >>> 'foo \ nbar \ nbaz \ nqux'.splitlines (True)
['foo \ n', 'bar \ n', 'baz \ n', 'qux']
>>> 'foo \ nbar \ nbaz \ nqux'.splitlines (1)
['foo \ n', 'bar \ n', 'baz \ n', 'qux']
  

22 питонических трюка для работы со строками | Ричард Куинн

Изображение предоставлено: https://www.pexels.com/photo/alphabet-close-up-communication-conceptual-278887/

Манипуляции со строками — это то, что мы, питонисты, много делаем. Вот 20 лучших советов и приемов, которые могут оказаться полезными!

Все эти примеры используют Python 3, на момент написания последней версии была 3.8.2. Если вы новичок в программировании, вам будет полезна моя статья Introduction to Strings.

0. Находится ли подстрока в строке?

Используйте встроенный компаратор в , который возвращает Истина или Ложь

1. Обращение строки

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

2. Сравните две строки на равенство

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

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

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

4. Эффективное объединение строк

Используйте соединение для пустой строки, чтобы объединить параметры.
Эта функция получает переменное количество аргументов с использованием специального индикатора * .

5.Строка пуста или нет?

Прекрасный объект string может содержать 0 символов или все пробелы, или даже быть объектом None .
Эту функцию можно использовать, если вы хотите проверить символьное или байтовое содержимое в строке.

6. Обрезать начальные и конечные пробелы

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

7. Создание строки случайных символов

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

8. Прочитать строки из файла в список

Объект чтения файлов f здесь неявно преобразуется в список.
Примечание: здесь мы открываем файл в режиме ‘r’ только для чтения.

9. Полностью разметить предложение

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

10. Выполнить код Python, найденный внутри строки

Здесь отображаются два метода. exec_string отправит содержимое строки в операционную систему. eval_string будет использовать Python для оценки строки.

Будьте осторожны с обоими: строки, которые вы выполняете, могут быть вредоносными!

11. Найдите подстроку между двумя маркерами

Используйте регулярные выражения и F-строки.

12. Удаление всех знаков препинания из строки

Модуль строк содержит список знаков пунктуации.
Используйте translate (см. # 21), чтобы удалить их из строки.

13. Кодирование и декодирование URL-адресов UTF-8

UTF-8 позволяет нам использовать расширенные символы двойного слова, такие как смайлики. Их необходимо закодировать, прежде чем их можно будет использовать в URL-адресе.

14. Использовать кодировку Base64 для строк

Base64 — это метод кодирования двоичных данных в виде строки для передачи в текстовых сообщениях.Вы также можете использовать его для кодирования строк UTF-8.

15. Вычислите сходство двух строк

Помимо использования расстояния Левенштейна в nltk.edit_distance , вы можете попробовать библиотеку difflib .
Значение 1,0 означает равенство.

16. Удалить символ по определенному индексу

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

17. Преобразование между CSV и списком

Значения, разделенные запятыми, встречаются повсюду, потому что Excel — лучшее универсальное решение любой проблемы с данными! 😉
Давайте возьмем одну строку CSV и преобразуем ее в список значений.

Строка 3 составляет список, разделяя строку ввода на каждые “,” разделители.

Теперь давайте сделаем обратное: возьмем список и вернем строку CSV.

18. Плетение двух ниток

Используйте zip_longest из модуля itertools , чтобы застегнуть две нити разной длины.
Это решение объединяет вывод со списком, который объединяет i + j .

19. Удалите ненужные символы из строки

Используйте функцию замены.Помните: вы не можете изменить значение строки на месте — строки неизменяемы.
Также см. №21.

20. Найдите индексные позиции символа в строке

Это решение использует понимание списка с фильтром, используя , если .

21. Переведите строку в Leetspeak

Используйте функции maketrans и translate .

Удачи, питонисты!

Учебные пособия и заметки по работе со струнами | Python

Строка Python:

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

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

Как создать строку и присвоить ее переменной

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

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

  >>> single_quote_character = 'a'
>>> print (одиночный_цифровый_символ)
а
>>> print (type (single_quote_character)) # проверяем тип переменной.
<класс 'str'>
  

Аналогично, вы можете присвоить одиночный символ переменной double_quote_character .Обратите внимание, что строка состоит из одного символа, но «заключена» в двойные кавычки.

  >>> double_quote_character = "b"
>>> print (двойной_цифровый_символ)
б
>>> print (type (двойной_цифровый_символ))
<класс 'str'>
  

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

  >>> double_quote_multiple_characters = "aeiou"
>>> single_quote_multiple_characters = 'aeiou'
>>> print (тип (двойные_цитаты_множественные_символы), тип (одинарные_цифровые_множественные_символы))
<класс 'str'> <класс 'str'>
  

Интересно, что если вы проверите эквивалентность одного другому с помощью ключевого слова is , оно вернет True.

  >>> print (double_quote_multiple_characters равно double_quote_multiple_characters)
Истинный
  

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

  >>> triple_quote_example = "" "это предложение, написанное в тройных кавычках" ""
>>> print (введите (тройной_цифтовый_пример))
<класс 'str'>
  

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

Строковые общие методы

2 возвращается, потому что позиция отдельных букв в строках имеет нулевой индекс. Таким образом, индекс «a» в «abcde» равен 0, индекс «b» равен 1 и так далее.

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

  подстрока в строке

    >>> # например, проверить, присутствует ли строка "i" в строке "pythonic" хотя бы один раз. «i» присутствует в строке. Следовательно, результат должен быть верным.
  >>> «я» в «питоническом»
  Истинный
  >>> # поскольку "x" не присутствует в строке "pythonic", приведенный ниже тест должен вернуть false
  >>> "x" в "pythonic" # "x" не присутствует в "pythonic"
  Ложь
    

• Присоединитесь к списку строк, используя метод соединения.Список строк записывается путем разделения последовательности запятой , и заключения всей группы скобками [...] . Для более подробного руководства по спискам перейдите к руководству по спискам Python.
  Вы можете присоединиться к списку строк, указав разделитель в качестве объекта, на который будет действовать метод join , и список строк в качестве аргумента.

    >>> # объединить список строк 1, 2, 3 с пробелом в качестве разделителя и 1,2,3 в качестве списка строк.Итак, результатом будут строки с пробелами между ними.
  >>> Combined_string = "" .join (["1", "2", "3"])
  '1 2 3'
    

• Разорвать строку по какому-либо правилу.
  Он принимает строку в качестве объекта, которому передается метод split с использованием оператора точки. В качестве параметра по умолчанию для разделения используется пробел.

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

  >>> # разделить строку «1 2 3» и вернуть список чисел.>>> "1 2 3" .split () # разделение
    ['1', '2', '3']
  

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

  >>> «1: 2: 3» .split («:»)
     [‘1’, ‘2’, ‘3’]
  

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

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

  >>> print ("Я люблю% s в% s"% ("программирование", "Python")) # шаблонные строки
    'Я люблю программировать на Python'
  

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

  >>> print ("Я люблю {программирование} на {python}". Формат (программирование = "программирование", python = "Python"))
'Я люблю программировать на Python'
  

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

Строка в Python считается верной, если это не пустая строка.Итак, получаем следующее:

  # Проверить истинностное значение пустой строки
>>> print (bool (""))
Ложь

# Проверить значение истинности непустой строки "x"
>>> print (bool ("x"))
Истинный
  

Предоставил: Джойдип Бхаттачарджи

Сравнение строк с использованием Python

В Python строки — это последовательности символов, которые фактически хранятся в памяти как объект. Каждый объект можно идентифицировать с помощью метода id () , как вы можете видеть ниже.Python пытается повторно использовать в памяти объекты с одинаковым значением, что также позволяет очень быстро сравнивать объекты в Python:

  $ питон
Python 2.7.9 (по умолчанию, 29 июня 2016 г., 13:08:31)
[GCC 4.9.2] в linux2
Для получения дополнительной информации введите «помощь», «авторские права», «кредиты» или «лицензия».
>>> a = "abc"
>>> b = "abc"
>>> c = "def"
>>> print (id (a), id (b), id (c))
(13994

41320, 1399441320, 13994

)
>>> выйти ()

Для сравнения строк Python предлагает несколько разных операторов.Сначала мы объясним их более подробно ниже. Во-вторых, мы рассмотрим модули string и re , которые содержат методы для обработки нечувствительных к регистру и неточных совпадений. В-третьих, для работы с многострочными строками очень удобен модуль difflib. Ряд примеров поможет вам понять, как их использовать.

Операторы == и! =

В качестве основного оператора сравнения вы захотите использовать == и ! = . Они работают точно так же, как и с целыми числами и значениями с плавающей запятой.Оператор == возвращает True , если есть точное совпадение, в противном случае будет возвращено False . Напротив, оператор ! = возвращает True , если совпадений нет, и в противном случае возвращает False . Листинг 1 демонстрирует это.

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

Листинг 1:

  # определить строки
listOfPlaces = ["Берлин", "Париж", "Лозанна"]
currentCity = "Лозанна"

для места в listOfPlaces:
    print ("сравнение% s с% s:% s"% (place, currentCity, place == currentCity))
  

При запуске скрипта Python сверху результат будет следующим:

  $ python3 comparing-strings.py
сравнение Берлина с Лозанной: Неверно
сравнение Парижа с Лозанной: Неверно
сравнение Лозанны с Лозанной: Верно
  

== и - это Операторы

Python имеет два оператора сравнения: == и - .На первый взгляд они кажутся одинаковыми, но на самом деле это не так. == сравнивает две переменные на основе их фактического значения. Напротив, оператор is сравнивает две переменные на основе идентификатора объекта и возвращает True , если две переменные относятся к одному и тому же объекту.

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

  >>> а = 1
>>> b = 1
>>> c = 2
>>> а это б
Истинный
>>> а есть с
Ложь
>>> id (а)
10771520
>>> id (b)
10771520
  

Как только значение изменится, Python повторно создаст объект и назначит переменную. В следующем фрагменте кода b получает значение 2, а затем b и c относятся к одному и тому же объекту.

  >>> b = 2
>>> id (b)
10771552
>>> id (c)
10771552
  

Практическое правило — использовать == при сравнении неизменяемых типов (например, целых чисел), а - при сравнении объектов.

Другие операторы сравнения

Для сравнения в лексикографическом порядке вы можете использовать операторы сравнения <, > , <= и > = . Само сравнение проводится посимвольно. Порядок зависит от порядка символов в алфавите. Этот порядок зависит от таблицы символов, которая используется на вашем компьютере при выполнении кода Python.

Имейте в виду, что порядок чувствителен к регистру.Например, латинский алфавит: «Автобус» стоит перед «автобусом». Листинг 2 показывает, как эти операторы сравнения работают на практике.

Листинг 2:

  # определить строки
listOfPlaces = ["Берлин", "Париж", "Лозанна"]
currentCity = "Лозанна"

для места в listOfPlaces:
    если место  currentCity:
            print ("% s идет после% s"% (place, currentCity))
    еще:
            print ("% s похож на% s"% (place, currentCity))
  

При запуске скрипта Python сверху результат будет следующим:

  $ python3 для сравнения строк-порядка.ру
Берлин предшествует Лозанне
Париж приходит после Лозанны
Лозанна похожа на Лозанну
  

Сравнение без учета регистра

Предыдущие примеры были посвящены точному совпадению строк. Чтобы обеспечить сравнение без учета регистра, Python предлагает специальные строковые методы, такие как upper () и lower () . Оба они напрямую доступны как методы соответствующего строкового объекта.

upper () преобразует всю строку в прописные буквы, а lower () в строчные буквы соответственно.В следующем листинге, основанном на листинге 1 , показано, как использовать метод lower () .

Листинг 3:

  # с использованием оператора ==
listOfPlaces = ["Берлин", "Париж", "Лозанна"]
currentCity = "lausANne"

для места в listOfPlaces:
    print ("сравнение% s с% s:% s"% (place, currentCity, place.lower () == currentCity.lower ()))
  

Результат выглядит следующим образом:

  $ python3 сравнение-strings-case-insensitive.py
сравнивая Берлин с Лозаной: Ложь
сравнивая Париж с Лозаной: ложь
сравнивая Лозанну с Лозанной: Верно
  

Использование регулярного выражения

Регулярное выражение - или для краткости «регулярное выражение» - определяет определенный шаблон символов.Что касается этой темы, Джеффри Фридл написал отличную книгу под названием «Освоение регулярных выражений», которую я очень рекомендую.

Чтобы использовать этот механизм в Python, сначала импортируйте модуль re, а затем определите конкретный шаблон. Опять же, следующий пример основан на листинге , листинг 1 . Шаблон поиска соответствует «заливу» и начинается со строчной или прописной буквы. А именно, следующий код Python находит все строки, в которых встречается шаблон поиска, независимо от того, в какой позиции строки - в начале, в середине или в конце.

Листинг 4:

  # импортировать дополнительный модуль
импорт ре

# определить список мест
listOfPlaces = ["Бэйсуотер", "Столовая бухта", "Пекин", "Бомбей"]

# определить строку поиска
pattern = re.compile ("[Bb] ay")

для места в listOfPlaces:
    если pattern.search (место):
        print ("% s соответствует поисковому шаблону"% place)
  

Результат выглядит следующим образом и соответствует "Bayswater", "Table Bay" и "Bombay" из списка мест:

  $ python3 сравнение строк-re.ру
Bayswater соответствует поисковому шаблону
Table Bay соответствует шаблону поиска
Бомбей соответствует поисковому шаблону
  

Многострочные сравнения и списки

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

В следующем примере ( листинг 5 ) сравниваются две многострочные строки построчно и показаны как удаления, так и добавления.После инициализации объекта Differ в строке 12 сравнение выполняется с использованием метода compare () в строке 15. Результат выводится на стандартный вывод (строка 18).

Листинг 5:

  # импортировать дополнительный модуль
импорт diffflib
 
# определить исходный текст
# взято из: https://en.wikipedia.org/wiki/Internet_Information_Services
original = ["Об IIS", "", "IIS 8.5 имеет несколько улучшений, связанных", "с производительностью в крупномасштабных сценариях, таких", "как те, которые используются коммерческими поставщиками хостинга и Microsoft", "собственными облачными предложениями."]

# определить измененный текст
edited = ["Об IIS", "", "В нем несколько улучшений, связанных", "с производительностью в крупномасштабных сценариях."]

# инициировать объект Differ
d = difflib.Differ ()
 
# вычислить разницу между двумя текстами
diff = d.compare (исходный, отредактированный)
 
# вывести результат
print ('\ n'.join (diff))
  

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

Заключение

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

Благодарности

Автор благодарит Мэнди Ноймайер за поддержку при подготовке статьи.

строк Python - Принципы Python

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

Что такое строка?

Строка - это последовательность букв. Другими словами, если у вас есть буквы в
строка, это строка.

В Python строки заключаются в кавычки. Это сказать Python
что он имеет дело со строкой, а не с переменной.

Примеры строк

Вот строка, представляющая имя:

  «Боб»
  

Вот строка, представляющая пароль:

  "mypassword123"
  

Вот другие примеры строк:

  «Привет, мир»
"это строка"
"ИКС"
""
  

Эта последняя строка известна как пустая строка .

Как использовать строки в Python?

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

  name = "Алиса"
  

Узнайте о струнах

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

Урок работает, позволяя вам писать и запускать код. Наша система автоматически
проверяет правильность ваших ответов и дает вам обратную связь.

Зачем нужны струны?

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

Программе могут потребоваться строки для представления:

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

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

Работа со строками

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

Например, допустим, что у нас есть такая строка:

  name = "Боб"
  

Теперь name [0] будет "B" , а name [1] будет "o" . Итак, если вы бежите
этот код:

  печать (имя [0])
  

На вашем экране будет напечатано B .

Это называется , нарезавшим строку. Вы используете квадратные скобки с двоеточием.
Опять же, индексация начинается с 0, а не с 1.

Например, допустим, что у нас есть такая строка:

  username = "iamthebob"
  

Затем мы можем извлечь первые три буквы:

  имя пользователя [0: 3]
  

Это будет «iam» .

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

  >>> username = "iamthebob"
>>> имя пользователя [3: 6]
'the'
  

Проверка, содержит ли строка что-либо

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

  username = "iamthebob"
если "bob" в имени пользователя:
    print («Это Боб!»)
  

Получение строки в качестве ввода

Вы можете вызвать функцию input , чтобы получить ввод от пользователя:

  username = input («Какое у вас имя пользователя?»)
  

Если вы все еще используете Python 2, вам придется вместо этого использовать raw_input () .

Объединение строк

Вы можете использовать + для объединения (объединения) строк:

  >>> print ("a" + "b")
ab
  

Можно даже умножить строку на число:

  >>> "а" * 3
'ааа'
  

Выход с переменными

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

В Python 3 для этого можно использовать так называемые f-строки. Вы ставите
f перед кавычками. Это позволяет вам помещать любые переменные внутрь
фигурные скобки внутри строки. Например:

  >>> name = "Bob"
>>> возраст = 33
>>> print (f "Привет, {имя}, тебе {age} лет")
Привет Боб, тебе 33 года
  

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

  print («Привет,% s, тебе% d лет»% (имя, возраст))
  

Здесь % s означает строку, а % d означает цифру.

Если вы хотите избежать f-строк, существует также метод формата , который вы можете использовать:

  >>> print ("Привет {}, тебе {} лет" .format (имя, возраст))
Привет Боб, тебе 33 года
  

Переворачивание струны

Требуется нарезка с отрицательным шагом:

  >>> print ("abcd" [:: - 1])
DCBA
>>> Приветствие = "Привет, мир"
>>> print (приветствие [:: - 1])
dlrow, olleH
  

Если вы не понимаете, что такое нарезка, не волнуйтесь - просто введите [:: - 1] в
конец вашей строки, и он будет перевернут.

Длина строки

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

  >>> len ("Здравствуйте")
5
>>> name = "Боб"
>>> print (len (имя))
3
  

Полезные строковые методы

Строки - это объекты. У них есть разные полезные методы. Вот некоторые из них.

Преобразование строки в нижний регистр

Используйте метод .lower () :

  >>> "Привет!" .Lower ()
'всем привет'
  

Преобразование строки в верхний регистр

Используйте .верхний () метод:

  >>> "Привет!" .Upper ()
'ВСЕМ ПРИВЕТ'
  

Замена части струны

Используйте метод .replace () для замены части строки другой:

  >>> "hi.there" .replace (".", "")
'всем привет'
  

Заменены все вхождения:

  >>> "привет, мир" .replace ("l", "xx")
'hexxxxo worxxd'
  

Убрать пробелы и табуляции

Используйте .strip () для удаления пробелов в начале и в конце
строки:

  >>> "эта строка не чистая .." .strip ()
"эта строка не чистая .."
  

Найти строку в другой строке

Используйте метод .find () , чтобы найти индекс:

  >>> "Привет" .find ("lo")
3
  

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

Используйте метод .split () , чтобы разбить строку на список:

  >>> "это - строка".расколоть(" - ")
['это', 'есть', 'а', 'строка']
  

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

  >>> "синтаксический анализ, это, csv" .split (",")
['parse', 'this', 'csv']
  

Проверить, начинается ли строка с

Используйте метод .startswith () :

  >>> "Привет" .startswith ("Он")
Истинный
  

Существует также метод .endswith () .

Практика использования струн

Наш практический урок позволит вам попрактиковаться в использовании струнных инструментов.
написав код и заставив его автоматически запускаться и проверяться.Попробуй это сейчас!

Быстро улучшите свои навыки Python

Самый быстрый способ научиться программированию - это много практиковаться. Изучите программирование
концепции, а затем напишите код, чтобы проверить свое понимание и закрепить его. Попробуйте наш онлайн
интерактивный курс Python сегодня - это бесплатно!

Узнать больше о курсе

Хотите быстро освоить Python? Попробуйте наши
интерактивные уроки сегодня! Членство 100% БЕСПЛАТНО это
только неделя!

Автоматизируйте скучную работу с помощью Python

Текст - одна из наиболее распространенных форм данных, которые будут обрабатывать ваши программы.Вы уже знаете, как объединить два строковых значения вместе с оператором + , но вы можете сделать гораздо больше. Вы можете извлекать частичные строки из строковых значений, добавлять или удалять интервалы, преобразовывать буквы в нижний или верхний регистр и проверять правильность форматирования строк. Вы даже можете написать код Python для доступа к буферу обмена для копирования и вставки текста.

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

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

Ввод строковых значений в коде Python довольно прост: они начинаются и заканчиваются одинарной кавычкой. Но как тогда использовать кавычки внутри строки? Наберите «Это кот Алисы». не будет работать, потому что Python считает, что строка заканчивается после Алисы , а остальная часть ( s cat. ') является недопустимым кодом Python. К счастью, есть несколько способов набирать строки.

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

 >>>  spam = "Это кот Алисы."  

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

Управляющий символ позволяет использовать символы, которые иначе невозможно поместить в строку. Управляющий символ состоит из обратной косой черты ( \ ), за которой следует символ, который вы хотите добавить в строку. (Несмотря на то, что он состоит из двух символов, его обычно называют единичным escape-символом.) Например, escape-символ для одиночной кавычки - \ '. Вы можете использовать это внутри строки, которая начинается и заканчивается одинарными кавычками. Чтобы увидеть, как работают escape-символы, введите в интерактивную оболочку следующее:

 >>>  spam = 'Передай привет маме Боба.' 

Python знает, что, поскольку одинарная кавычка в Bob \ 's имеет обратную косую черту, это не одинарная кавычка, предназначенная для завершения строкового значения. Управляющие символы \ ' и \ " позволяют помещать одинарные и двойные кавычки внутри строк соответственно.

В таблице 6-1 перечислены управляющие символы, которые вы можете использовать.

Таблица 6-1. Побег персонажей

Введите в интерактивную оболочку следующее:

 >>>  print ("Привет! \ NКак дела? \ NВсе хорошо.") 
Привет!
Как твои дела?
У меня все хорошо. 

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

 >>>  print (r'Это кошка Кэрол. ') 
Это кошка Кэрол. 

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

Многострочные струны с тройными кавычками

Хотя для помещения новой строки в строку можно использовать escape-символ \ n , часто бывает проще использовать многострочные строки. Многострочная строка в Python начинается и заканчивается тремя одинарными или тремя двойными кавычками. Любые кавычки, табуляции или символы новой строки между «тройными кавычками» считаются частью строки.Правила Python для блоков не применяются к строкам внутри многострочной строки.

Откройте редактор файлов и напишите следующее:

 print ('' Дорогая Алиса,

Кошка Евы арестована за кражу кошек, кражу со взломом и вымогательство.

Искренне,
Боб '') 

Сохраните эту программу как catnapping.py и запустите ее. Результат будет выглядеть так:

 Дорогая Алиса,

Кошка Евы арестована за кражу кошек, кражу со взломом и вымогательство.Искренне,
Боб 

Обратите внимание, что символ одинарной кавычки в Eve's не нужно экранировать. В необработанных строках экранирование одинарных и двойных кавычек необязательно. Следующий вызов print () выведет идентичный текст, но не использует многострочную строку:

 print ('Дорогая Алиса, \ n \ n кошка Евы арестована за то, что она рожала, кошка
кража со взломом и вымогательство. \ n \ nС уважением, \ nБоб ') 

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

 "" "Это тестовая программа на Python.
Написано Элом Свигартом [email protected]

Эта программа была разработана для Python 3, а не для Python 2.
"" "

def spam ():
    "" "Это многострочный комментарий, чтобы помочь
    объясните, что делает функция spam (). "" "
    print ('Привет!') 

Индексирование и нарезка строк

Строки используют индексы и срезы так же, как и списки. Вы можете вспомнить строку «Hello world!» как список, а каждый символ в строке как элемент с соответствующим индексом.

 'Здравствуйте! '
    0 1 2 3 4 5 6 7 8 9 10 11 

Пробел и восклицательный знак учитываются при подсчете символов, поэтому «Hello world!» состоит из 12 символов, от H с индексом 0 до ! при индексе 11.

Введите в интерактивную оболочку следующее:

 >>>  spam = 'Hello world!' 
>>>  спам [0] 
'ЧАС'
>>>  спам [4] 
'о'
>>>  спам [-1] 
'!'
>>>  спам [0: 5] 
'Привет'
>>>  спам [: 5] 
'Привет'
>>>  спам [6:] 
'Мир!' 

Если вы укажете индекс, вы получите символ в этой позиции в строке.Если вы укажете диапазон от одного индекса до другого, начальный индекс будет включен, а конечный - нет. Поэтому, если спам - это «Привет, мир!» , спам [0: 5] - это 'Hello' . Подстрока, полученная из спама [0: 5] , будет включать все, от спама [0] до спама [4] , без пробела с индексом 5.

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

 >>>  spam = 'Hello world!' 
>>>  fizz = спам [0: 5] 
>>>  fizz 
'Привет' 

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

Операторы in и not in со строками

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

 >>>  «Привет» в «Привет, мир» 
Истинный
>>>  'Hello' в 'Hello' 
Истинный
>>>  'HELLO' в 'Hello World' 
Ложь
>>>  'в' спаме '
Истинный
>>>  «кошек» нет в «кошках и собаках» 
Ложь 

Эти выражения проверяют, можно ли найти первую строку (точную строку с учетом регистра) во второй строке.

Урок 20 - Строковые методы и модуль pyperclip

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

Строковые методы upper (), lower (), isupper () и islower ()

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

 >>>  spam = 'Hello world!' 
>>>  spam = spam.upper () 
>>>  спам 
'ПРИВЕТ, МИР!'
>>>  spam = spam.lower () 
>>>  спам 
'Привет, мир!' 

Обратите внимание, что эти методы не изменяют саму строку, а возвращают новые строковые значения. Если вы хотите изменить исходную строку, вы должны вызвать upper () или lower () в строке, а затем назначить новую строку переменной, в которой был сохранен оригинал.Вот почему вы должны использовать spam = spam.upper () , чтобы изменить строку в spam вместо простого spam.upper () . (Это похоже на то, как если бы переменная яйца содержала значение 10 . Запись яиц + 3 не изменяет значение яиц , но яиц = яйца + 3 изменяет.)

Методы upper () и lower () полезны, если вам нужно провести сравнение без учета регистра. Строки 'great' и 'GREat' не равны друг другу.Но в следующей небольшой программе не имеет значения, набирает ли пользователь Great , GREAT или grEAT , потому что сначала строка преобразуется в нижний регистр.

 print ('Как дела?')
чувство = вход ()
if feel.lower () == 'отлично':
    print ('Я тоже прекрасно себя чувствую.')
еще:
    print («Я надеюсь, что остаток дня у вас будет хорошо».) 

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

 Как дела?
  БОЛЬШОЙ 
Я тоже прекрасно себя чувствую. 

Методы isupper () и islower () вернут логическое значение True , если в строке есть хотя бы одна буква и все буквы в верхнем или нижнем регистре соответственно. В противном случае метод возвращает False .Введите в интерактивную оболочку следующее и обратите внимание на то, что возвращает каждый вызов метода:

 >>>  spam = 'Hello world!' 
>>>  spam.islower () 
Ложь
>>>  spam.isupper () 
Ложь
>>>  'HELLO'.isupper () 
Истинный
>>>  'abc12345'.islower () 
Истинный
>>>  '12345'.islower () 
Ложь
>>>  '12345'.isupper () 
Ложь 

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

 >>>  'Привет'. Верхний () 
'ПРИВЕТ'
>>>  'Hello'.upper (). Lower () 
'Привет'
>>>  'Hello'.upper (). Lower (). Upper () 
'ПРИВЕТ'
>>>  'ПРИВЕТ. Ниже () 
'Привет'
>>>  'HELLO'.lower (). Islower () 
Правда 

Наряду с islower () и isupper () существует несколько строковых методов, имена которых начинаются со слова - .Эти методы возвращают логическое значение, описывающее характер строки. Вот некоторые общие - X строковые методы:

• isalpha () возвращает Истина , если строка состоит только из букв и не пуста.

• isalnum () возвращает Истина , если строка состоит только из букв и цифр и не является пустой.

• isdecimal () возвращает Истина , если строка состоит только из числовых символов и не является пустой.

• isspace () возвращает Истинно , если строка состоит только из пробелов, табуляции и новых строк и не пуста.

• istitle () возвращает True , если строка состоит только из слов, начинающихся с заглавной буквы, за которой следуют только строчные буквы.

Введите в интерактивную оболочку следующее:

 >>>  'привет'.isalpha () 
Истинный
>>>  'hello123'.isalpha () 
Ложь
>>>  'hello123'.isalnum () 
Истинный
>>>  'привет'.isalnum () 
Истинный
>>>  '123'.isdecimal () 
Истинный
>>>  '' .isspace () 
Истинный
>>>  'This Is Title Case'. Название () 
Истинный
>>>  'This Is Title Case 123' .istitle () 
Истинный
>>>  «Это не титульный лист».istitle () 
Ложь
>>>  'Это тоже НЕ титульный регистр' .istitle () 
Ложь 

is X строковые методы полезны, когда вам нужно проверить вводимые пользователем данные. Например, следующая программа неоднократно запрашивает у пользователей их возраст и пароль, пока они не введут действительные данные. Откройте новое окно редактора файлов и войдите в эту программу, сохранив ее как validateInput.py :

, пока True:
    print ('Введите свой возраст:')
    возраст = вход ()
    если возраст.isdecimal ():
        перемена
    print ('Введите число, соответствующее вашему возрасту.')

в то время как True:
    print ('Выберите новый пароль (только буквы и цифры):')
    пароль = вход ()
    если password.isalnum ():
        перемена
    print ('Пароли могут состоять только из букв и цифр.') 

В первом цикле while мы запрашиваем у пользователя его возраст и сохраняем введенные данные в age . Если age является допустимым (десятичным) значением, мы выходим из первого цикла и и переходим ко второму, который запрашивает пароль.В противном случае мы сообщаем пользователю, что ему нужно ввести число, и снова просим ввести свой возраст. Во втором цикле while мы запрашиваем пароль, сохраняем ввод пользователя в password и выходим из цикла, если ввод был буквенно-цифровым. Если это не так, нас не устраивает, поэтому мы сообщаем пользователю, что пароль должен быть буквенно-цифровым, и снова просим его ввести пароль.

При запуске вывод программы выглядит следующим образом:

 Введите свой возраст:
  сорок два 
Пожалуйста, введите число, соответствующее вашему возрасту.Введите свой возраст:
  42 
Выберите новый пароль (только буквы и цифры):
  secr3t! 
Пароли могут состоять только из букв и цифр.
Выберите новый пароль (только буквы и цифры):
  секр3т  

Вызывая isdecimal () и isalnum () для переменных, мы можем проверить, являются ли значения, хранящиеся в этих переменных, десятичными или нет, буквенно-цифровыми или нет. Здесь эти тесты помогают нам отклонить ввод 42 , принять 42 и отклонить secr3t! и принимаем secr3t .

Строковые методы startwith () и endwith ()

Методы startwith () и endwith () возвращают True , если строковое значение, для которого они вызываются, начинается или заканчивается (соответственно) строкой, переданной в метод; в противном случае они возвращают Ложь . Введите в интерактивную оболочку следующее:

 >>>  'Hello world!'. Начинается с ('Hello') 
Истинный
>>>  «Привет, мир!».заканчивается ('мир!') 
Истинный
>>>  'abc123'.startswith (' abcdef ') 
Ложь
>>>  'abc123'.endswith ('12') 
Ложь
>>>  'Hello world!'. Начинается с ('Hello world!') 
Истинный
>>>  'Hello world!'. Заканчивается на ('Hello world!') 
Правда 

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

Строковые методы join () и split ()

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

 >>>  ',' .join (['кошки', 'крысы', 'летучие мыши']) 
'кошки, крысы, летучие мыши'
>>>  ''.join (['Мой', 'имя', 'есть', 'Саймон']) 
"Меня зовут Саймон"
>>>  'ABC'.join ([' My ',' name ',' is ',' Simon ']) 
"MyABCnameABCisABCSimon" 

Обратите внимание, что строка, которую вызывает join () , вставляется между каждой строкой аргумента списка. Например, когда join (['cats', 'rats', 'bats']) вызывается в строке ',' , возвращаемая строка будет "cats, rats, bats".

Помните, что join () вызывается для строкового значения и передается значение списка.(Легко случайно вызвать это наоборот.) Метод split () делает обратное: он вызывается для строкового значения и возвращает список строк. Введите в интерактивную оболочку следующее:

 >>>  'Меня зовут Саймон'. Split () 
["Мой", "имя", "есть", "Симон"] 

По умолчанию строка «Меня зовут Саймон» разделяется везде, где встречаются пробельные символы, такие как пробел, табуляция или символы новой строки. Эти пробельные символы не включаются в строки в возвращаемом списке.Вы можете передать строку-разделитель методу split () , чтобы указать другую строку для разделения. Например, введите в интерактивную оболочку следующее:

 >>>  'MyABCnameABCisABCSimon'.split (' ABC ') 
["Мой", "имя", "есть", "Симон"]
>>>  'Меня зовут Симон'.split (' m ') 
['My na', 'e is Si', 'on'] 

Обычно split () используется для разделения многострочной строки по символам новой строки. Введите в интерактивную оболочку следующее:

 >>>  spam = '' 'Уважаемая Алиса, 
  Как дела? Я в порядке.
  В холодильнике есть тара 
  с пометкой «Эксперимент с молоком». 

  Пожалуйста, не пейте. 
  С уважением, 
  Боб '
>>>  spam.split ('\ n') 
['Дорогая Алиса', 'Как дела? Я в порядке. ',' В контейнере
холодильник ',' с пометкой "Эксперимент с молоком". ',' ',' Пожалуйста, не пейте его. ',
«С уважением», «Боб»] 

Передача split () аргумента '\ n' позволяет разделить многострочную строку, хранящуюся в spam , по символам новой строки и вернуть список, в котором каждый элемент соответствует одной строке строки.

Выравнивание текста по ширине с помощью rjust (), ljust () и center ()

Строковые методы rjust () и ljust () возвращают дополненную версию строки, для которой они вызываются, с пробелами, вставленными для выравнивания текста. Первый аргумент обоих методов - это целая длина выровненной строки. Введите в интерактивную оболочку следующее:

 >>>  'Привет'. Rjust (10) 
'     Привет'
>>>  'Привет'. Rjust (20) 
'               Привет'
>>>  'Hello World'.rjust (20) 
'         Привет, мир'
>>>  'Hello'.ljust (10) 
'Привет' 

'Hello'. Rjust (10) говорит, что мы хотим выровнять 'Hello' по правому краю в строке общей длиной 10 . «Привет» - это пять символов, поэтому слева от него будет добавлено пять пробелов, что даст нам строку из 10 символов с выравниванием «Привет» по правому краю.

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

 >>>  'Привет'. Rjust (20, '*') 
'***************Привет'
>>>  'Hello'.ljust (20,' - ') 
«Привет ---------------» 

Строковый метод center () работает аналогично ljust () и rjust () , но центрирует текст, а не выравнивает его по левому или правому краю. Введите в интерактивную оболочку следующее:

 >>>  'Привет'. Центр (20) 
'       Привет       '
>>>  'Привет'.центр (20, '=') 
'======= Привет ========' 

Эти методы особенно полезны, когда вам нужно напечатать табличные данные с правильным интервалом. Откройте новое окно редактора файлов и введите следующий код, сохранив его как picnicTable.py :

 def printPicnic (itemsDict, leftWidth, rightWidth):
    print ('ПОЗИЦИИ'. center (leftWidth + rightWidth, '-'))
    для k, v в itemsDict.items ():
        print (k.ljust (leftWidth, '.') + str (v) .rjust (rightWidth))
picnicItems = {'бутерброды': 4, 'яблоки': 12, 'чашки': 4, 'печенье': 8000}
printPicnic (picnicItems, 12, 5)
printPicnic (picnicItems, 20, 6) 

В этой программе мы определяем метод printPicnic () , который будет использовать словарь информации и использовать center () , ljust () и rjust () для отображения этой информации в аккуратно выровненном виде. табличный формат.

Словарь, который мы передадим в printPicnic () , будет picnicItems . В picnicItems у нас есть 4 бутерброда, 12 яблок, 4 чашки и 8000 печенья. Мы хотим организовать эту информацию в два столбца, с названием товара слева и количеством справа.

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

printPicnic () принимает словарь, leftWidth для левого столбца таблицы и rightWidth для правого столбца.Он печатает заголовок, PICNIC ITEMS , по центру над таблицей. Затем он просматривает словарь, печатая каждую пару «ключ-значение» в строке, где ключ выравнивается по левому краю и дополняется точками, а значение выравнивается по правому краю и дополняется пробелами.

После определения printPicnic () мы определяем словарь picnicItems и дважды вызываем printPicnic () , передавая ему разную ширину для левого и правого столбца таблицы.

При запуске этой программы предметы для пикника отображаются дважды.В первый раз ширина левого столбца составляет 12 символов, а ширина правого столбца - 5 символов. Во второй раз они имеют ширину 20 и 6 знаков соответственно.

 --- ПРЕДМЕТЫ ПИКНИКА--
бутерброды .. 4
яблоки ...... 12
чашки ........ 4
печенье ..... 8000
------- ПРЕДМЕТЫ ПИКНИКА -------
бутерброды .......... 4
яблоки .............. 12
чашки ................ 4
печенье ............. 8000 

Использование rjust () , ljust () и center () позволяет обеспечить аккуратное выравнивание строк, даже если вы не знаете, сколько символов в ваших строках.

Удаление пробелов с помощью strip (), rstrip () и lstrip ()

Иногда вам может потребоваться удалить символы пробела (пробел, табуляция и новая строка) с левой, правой или обеих сторон строки. Строковый метод strip () вернет новую строку без каких-либо пробелов в начале и в конце. Методы lstrip () и rstrip () удаляют пробельные символы с левого и правого концов соответственно. Введите в интерактивную оболочку следующее:

 >>>  spam = 'Hello World' 
>>>  спама.полоса () 
'Привет, мир'
>>>  spam.lstrip () 
'Привет, мир '
>>>  spam.rstrip () 
"Привет, мир" 

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

 >>>  spam = 'SpamSpamBaconSpamEggsSpamSpam' 
>>>  spam.strip ('ampS') 
'BaconSpamEggs' 

Передача strip () аргумента 'ampS' скажет ему удалить вхождения a , m , p и capital S с концов строки, хранящейся в spam .Порядок символов в строке, переданной в strip () , не имеет значения: strip ('ampS') будет делать то же самое, что и strip ('mapS') или strip ('Spam') .

Копирование и вставка строк с помощью модуля pyperclip

Модуль pyperclip имеет функций copy () и paste () , которые могут отправлять текст и получать текст из буфера обмена вашего компьютера. Отправка вывода вашей программы в буфер обмена позволит легко вставить его в электронную почту, текстовый редактор или другое программное обеспечение.

Pyperclip не поставляется с Python. Чтобы установить его, следуйте инструкциям по установке сторонних модулей в Приложении A. После установки модуля pyperclip введите в интерактивную оболочку следующее:

 >>>  импорт pyperclip 
>>>  pyperclip.copy ('Привет, мир!') 
>>>  pyperclip.paste () 
'Привет, мир!' 

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

 >>>  pyperclip.paste () 
'Например, если я скопировал это предложение в буфер обмена, а затем вызвал
paste (), это будет выглядеть так: '

У вас, вероятно, есть учетные записи на многих разных веб-сайтах. Использовать один и тот же пароль для каждого из них - плохая привычка, потому что, если на каком-либо из этих сайтов есть брешь в безопасности, хакеры узнают пароль для всех ваших учетных записей.Лучше всего использовать на вашем компьютере программу диспетчера паролей, которая использует один мастер-пароль для разблокировки диспетчера паролей. Затем вы можете скопировать любой пароль учетной записи в буфер обмена и вставить его в поле «Пароль» веб-сайта.

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

Шаг 1. Разработка программы и структуры данных

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

Откройте новое окно редактора файлов и сохраните программу под именем pw.py . Вам нужно запустить программу с номером #! ( shebang ) (см. Приложение B), а также следует написать комментарий, который кратко описывает программу. Поскольку вы хотите связать имя каждой учетной записи с паролем, вы можете сохранить их в виде строк в словаре.Словарь будет структурой данных, которая организует данные вашей учетной записи и пароля. Сделайте так, чтобы ваша программа выглядела так:

 #! python3
# pw.py - небезопасная программа для хранения паролей.

ПАРОЛИ = {'электронная почта': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
             'блог': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
             'багаж': '12345'} 

Шаг 2. Обработка аргументов командной строки

Аргументы командной строки будут сохранены в переменной sys.argv . (См. Приложение B для получения дополнительной информации о том, как использовать аргументы командной строки в ваших программах.) Первым элементом в списке sys.argv всегда должна быть строка, содержащая имя файла программы ( 'pw.py' ), и второй элемент должен быть первым аргументом командной строки. Для этой программы этот аргумент - имя учетной записи, пароль которой вы хотите. Поскольку аргумент командной строки является обязательным, вы показываете пользователю сообщение об использовании, если он забыл добавить его (то есть, если sys.В списке argv меньше двух значений). Сделайте так, чтобы ваша программа выглядела так:

 #! python3
# pw.py - небезопасная программа для хранения паролей.

ПАРОЛИ = {'электронная почта': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
             'блог': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
             'багаж': '12345'}

  импорт sys 
 , если len (sys.argv) <2: 
      print ('Использование: python pw.py [учетная запись] - скопировать пароль учетной записи ») 
      sys.выход () 

  account = sys.argv [1] # первый аргумент командной строки - это имя учетной записи  

Шаг 3. Скопируйте правильный пароль

Теперь, когда имя учетной записи хранится в виде строки в переменной account , вам нужно посмотреть, существует ли она в словаре PASSWORDS в качестве ключа. Если это так, вы хотите скопировать значение ключа в буфер обмена с помощью pyperclip.copy () . (Поскольку вы используете модуль pyperclip , вам необходимо импортировать его.) Обратите внимание, что на самом деле вам не нужно переменная account ; вы можете просто использовать sys.argv [1] везде, где в этой программе используется учетная запись . Но переменная с именем account гораздо более читабельна, чем что-то загадочное, например sys.argv [1] .

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

 #! python3
# pw.py - небезопасная программа для хранения паролей.
ПАРОЛИ = {'электронная почта': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
             'блог': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
             'багаж': '12345'}

import sys,  pyperclip 
если len (sys.argv) <2:
    print ('Использование: py pw.py [учетная запись] - скопировать пароль учетной записи »)
    sys.exit ()

account = sys.argv [1] # первый аргумент командной строки - это имя учетной записи

  если аккаунт в ПАРОЛЯХ: 
      pyperclip.copy (ПАРОЛИ [аккаунт]) 
      print ('Пароль для' + учетной записи + 'скопирован в буфер обмена.') 
  еще: 
      print («Нет учетной записи с именем» + учетная запись)  

Этот новый код ищет имя учетной записи в словаре PASSWORDS .Если имя учетной записи является ключом в словаре, мы получаем значение, соответствующее этому ключу, копируем его в буфер обмена и печатаем сообщение о том, что мы скопировали значение. В противном случае мы печатаем сообщение о том, что учетной записи с таким именем нет.

Это полный сценарий. Используя инструкции в Приложении B для легкого запуска программ командной строки, теперь у вас есть быстрый способ скопировать пароли своей учетной записи в буфер обмена. Вам нужно будет изменить значение словаря PASSWORDS в источнике всякий раз, когда вы захотите обновить программу с новым паролем.

Конечно, вы, вероятно, не хотите хранить все свои пароли в одном месте, где кто-либо может легко их скопировать. Но вы можете изменить эту программу и использовать ее для быстрого копирования обычного текста в буфер обмена. Предположим, вы отправляете несколько электронных писем, в которых много одинаковых общих абзацев. Вы можете поместить каждый абзац в качестве значения в словарь PASSWORDS (вы, вероятно, захотите переименовать словарь на этом этапе), и тогда у вас будет способ быстро выбрать и скопировать один из многих стандартных фрагментов текста в буфер обмена.

В Windows вы можете создать командный файл для запуска этой программы в окне выполнения WIN-R. (Дополнительные сведения о пакетных файлах см. В Приложении B.) Введите следующее в редакторе файлов и сохраните файл как pw.bat в папке C: \ Windows :

 @ py.exe C: \ Python34 \ pw.py% *
@pause 

После создания этого командного файла для запуска защищенной паролем программы в Windows достаточно нажать WIN-R и ввести pw <имя учетной записи> .

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

Скрипт bulletPointAdder.py получит текст из буфера обмена, добавит звездочку и пробел в начало каждой строки, а затем вставит этот новый текст в буфер обмена. Например, если я скопировал следующий текст (для статьи Википедии «Список списков списков») в буфер обмена:

 Списки животных
Списки аквариумной жизни
Списки биологов по авторскому аббревиатуре
Списки сортов 

, а затем запустил bulletPointAdder.py , буфер обмена будет содержать следующее:

 * Списки животных
* Списки аквариумной жизни
* Списки биологов по аббревиатуре автора.
* Списки сортов 

Этот текст с префиксом в виде звездочки готов для вставки в статью Википедии в виде маркированного списка.

Шаг 1. Копирование и вставка из буфера обмена

Вы хотите, чтобы программа bulletPointAdder.py выполняла следующие действия:

1. Вставить текст из буфера обмена

2. Сделайте что-нибудь с этим

3. Скопируйте новый текст в буфер обмена

Этот второй шаг немного сложен, но шаги 1 и 3 довольно просты: они просто задействуют pyperclip .copy () и pyperclip.paste () функций. А пока давайте просто напишем часть программы, которая охватывает шаги 1 и 3. Введите следующее, сохранив программу как bulletPointAdder.py :

 #! python3
# bulletPointAdder.py - добавляет маркеры Википедии в начало
# каждой строки текста в буфере обмена.

импортировать pyperclip
текст = pyperclip.paste ()

# TODO: Разделите линии и добавьте звезды.

pyperclip.copy (текст) 

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

Шаг 2. Разделите строки текста и добавьте звезду

Вызов pyperclip.paste () возвращает весь текст в буфере обмена как одну большую строку. Если бы мы использовали пример «Список списков списков», строка, хранящаяся в тексте , выглядела бы так:

 'Списки животных \ nСписки аквариумной жизни \ nСписки биологов по авторам
аббревиатура \ nСписок сортов 

\ n символов новой строки в этой строке заставляют ее отображаться с несколькими строками при печати или вставке из буфера обмена.В этом строковом значении много «строк». Вы хотите добавить звезду в начало каждой из этих строк.

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

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

 #! python3
# bulletPointAdder.py - добавляет маркеры Википедии в начало
# каждой строки текста в буфере обмена.

импортировать pyperclip
текст = pyperclip.paste ()

  # Разделите строки и добавьте звезды. 
  строк = text.split ('\ n') 
  for i in range (len (lines)): # перебирать все индексы в списке "lines" 
      lines [i] = '*' + lines [i] # добавить звездочку к каждой строке в списке "lines" 

pyperclip.copy (текст) 

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

Шаг 3. Присоединяйтесь к измененным линиям

Список строк теперь содержит измененные строки, начинающиеся со звездочек. Но pyperclip.copy () ожидает одно строковое значение, а не список строковых значений. Чтобы создать это одностроковое значение, передайте строк в метод join () , чтобы получить единую строку, объединенную из строк списка.Сделайте так, чтобы ваша программа выглядела так:

 #! python3
# bulletPointAdder.py - добавляет маркеры Википедии в начало
# каждой строки текста в буфере обмена.

импортировать pyperclip
текст = pyperclip.paste ()

# Разделите строки и добавьте звезды.
строки = текст.split ('\ n')
for i in range (len (lines)): # перебирать все индексы для списка "строк"
    lines [i] = '*' + lines [i] # добавить звездочку к каждой строке в списке "строк"
  text = '\ n'.join (строки) 
пиперклип.копия (текст) 

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

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

8 продвинутых советов по освоению строк Python | автор: Nik Piepenbreier

Строки Python кажутся простыми, но они невероятно гибкие и используются повсюду!

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

При работе с неструктурированными данными может быть очень полезно идентифицировать определенные слова или другие подстроки в более крупной строке.Самый простой способ сделать это - использовать оператор in .

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

В приведенном ниже примере у вас есть список различных регионов, и вы хотите знать, присутствует ли строка «Запад» в каждом элементе списка.

Проверка принадлежности строки. Источник: Nik Piepenbreier

F-строки были представлены в Python 3.6, и они не получили достаточного признания.

Я не зря говорю, что они волшебные.Они:

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

Но какие они? F-строки (или форматированные строковые литералы) позволяют помещать переменные (или любое выражение) в строки. Затем выражения выполняются во время выполнения.

Чтобы записать f-строку, добавьте к ней префикс «f».

Давайте посмотрим на пример:

струн F - потрясающие. Источник: Nik Piepenbreier

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

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

Обращение строки. Источник: Nik Piepenbreier

Для замены подстрок можно использовать метод replace. Это работает для любого типа строки, включая простой пробел (поскольку Python не имеет встроенных методов для удаления пробелов).

Давайте посмотрим на пример:

Замена подстрок. Источник: Nik Piepenbreier

Строки Python являются повторяемыми объектами (такими же, как списки, наборы и т. Д.).

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

Итерация по строкам. Источник: Nik Piepenbreier

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

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

• .upper () вернет строку со всеми символами в верхнем регистре
• .lower () вернет строку со всеми символами в нижнем регистре
• .title () будет использовать каждое слово в строке с заглавной буквы.

Давайте посмотрим на это в действии:

Оболочка строки формата. Источник: Nik Piepenbreier

Объединив все, что вы уже узнали, вы можете легко проверить, является ли строка палиндромом, используя срез [:: - 1].

Слово или фраза считаются палиндромом, если они пишутся так же, как вперед и назад.

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

Проверить палиндромы.Источник: Nik Piepenbreier

Анаграмма - это слово или фраза, образованные путем перестановки другого слова. Короче говоря, два слова являются анаграммами, если у них одинаковые буквы.