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

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

Занятие 5. Строки

1. Строки

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

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

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

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

int().

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

2. Срезы (slices)

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

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

S[3] == 'l', S[4] == 'o'.

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

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

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

, S[-5] == 'H'.

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

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

Если же номер символа в срезе строки

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

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

S[1:-1] — это строка без первого и последнего символа (срез начинается с символа с индексом 1 и заканчиватеся индексом -1, не включая его).

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

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

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

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

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

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

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

Обратите внимание на то, как похож третий параметр среза на третий параметр функции range():

s = 'abcdefghijklm'
print(s[0:10:2])
for i in range(0, 10, 2):
    print(i, s[i])

3. Методы

Метод — это функция, применяемая к объекту, в данном случае — к строке. Метод вызывается в виде Имя_объекта.Имя_метода(параметры). Например, S.find("e") — это применение к строке S метода find с одним параметром "e".

3.1. Методы find и rfind

Метод find находит в данной строке (к которой применяется метод) данную подстроку (которая передается в качестве параметра). Функция возвращает индекс первого вхождения искомой подстроки.

Если же подстрока не найдена, то метод возвращает значение -1.

S = 'Hello'
print(S.find('e'))
# вернёт 1
print(S.find('ll'))
# вернёт 2
print(S.find('L'))
# вернёт -1

Аналогично, метод rfind возвращает индекс последнего вхождения данной строки (“поиск справа”).

S = 'Hello'
print(S.find('l'))
# вернёт 2
print(S.rfind('l'))
# вернёт 3

Если вызвать метод find с тремя параметрами

S.find(T, a, b), то поиск будет осуществляться в срезе S[a:b]. Если указать только два параметра S.find(T, a), то поиск будет осуществляться в срезе S[a:], то есть начиная с символа с индексом a и до конца строки. Метод S.find(T, a, b) возращает индекс в строке S, а не индекс относительно среза.

3.2. Метод replace

Метод replace заменяет все вхождения одной строки на другую. Формат: S.replace(old, new) — заменить в строке S все вхождения подстроки old на подстроку new.

Пример:

print('Hello'.replace('l', 'L'))
# вернёт 'HeLLo'

Если методу replace задать еще один параметр: S.replace(old, new, count), то заменены будут не все вхождения, а только не больше, чем первые count из них.

print('Abrakadabra'.replace('a', 'A', 2))
# вернёт 'AbrAkAdabra'

3.3. Метод count

Подсчитывает количество вхождений одной строки в другую строку. Простейшая форма вызова S.count(T)  возвращает число вхождений строки T внутри строки S. При этом подсчитываются только непересекающиеся вхождения, например:

print('Abracadabra'.count('a'))
# вернёт 4
print(('a' * 10).count('aa'))
# вернёт 5

При указании трех параметров S.count(T, a, b), будет выполнен подсчет числа вхождений строки T в срезе S[a:b].

---

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

Телеграм-канал создателя Питонтьютора 🌈

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

Последнее обновление: 05.02.2022

Строка представляет последовательность символов в кодировке Unicode, заключенных в кавычки. Причем для определения строк Python позволяет использовать как одинарные, так и двойные кавычики:

message = "Hello World!"
print(message)  # Hello World!

name = 'Tom'
print(name)  # Tom

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

text = ("Laudate omnes gentes laudate "
        "Magnificat in secula ")
print(text)

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

'''
Это комментарий
'''
text = '''Laudate omnes gentes laudate
Magnificat in secula
Et anima mea laudate
Magnificat in secula 
'''
print(text)

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

Управляющие последовательности в строке

Строка может содержать ряд специальных символов — управляющих последовательностей или escape-последовательности. Некоторые из них:

• \: позволяет добавить внутрь строки слеш

• \’: позволяет добавить внутрь строки одинарную кавычку

• \»: позволяет добавить внутрь строки двойную кавычку

• \n: осуществляет переход на новую строку

• \t: добавляет табуляцию (4 отступа)

Используем некоторые последовательностей:

text = "Message:\n\"Hello World\""
print(text)

Консольный вывод программы:

Message:
"Hello World"

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

path = "C:\python\name.txt"
print(path)

Здесь переменная path содержит некоторый путь к файлу. Однако внутри строки встречаются символы «\n», которые будут интерпретированы как управляющая последовательность. Так, мы получим следующий консольный вывод:

C:\python
ame.txt

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

path = r"C:\python\name.txt"
print(path)

Вставка значений в строку

Python позволяет встравивать в строку значения других переменных. Для этого внутри строки переменные размещаются в фигурных скобках {}, а перед всей строкой ставится символ f:

userName = "Tom"
userAge = 37
user = f"name: {userName}  age: {userAge}"
print(user)   # name: Tom  age: 37

В данном случае на место {userName} будет вставляться значение переменной userName. Аналогично на вместо {userAge} будет вставляться значение переменной userAge.

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

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

string = "hello world"
c0 = string[0]  # h
print(c0)
c6 = string[6]  # w
print(c6)

c11 = string[11]  # ошибка IndexError: string index out of range
print(c11)

Индексация начинается с нуля, поэтому первый символ строки будет иметь индекс 0. А если мы попытаемся обратиться к индексу, которого нет в строке, то мы получим исключение IndexError. Например, в случае выше длина строки 11 символов, поэтому ее символы будут иметь индексы от 0 до 10.

Чтобы получить доступ к символам, начиная с конца строки, можно использовать отрицательные индексы. Так, индекс -1 будет представлять последний символ, а -2 — предпоследний символ и так далее:

string = "hello world"
c1 = string[-1]  # d
print(c1)
c5 = string[-5]  # w
print(c5)

При работе с символами следует учитывать, что строка — это неизменяемый (immutable) тип, поэтому если мы попробуем изменить какой-то отдельный символ строки, то мы получим ошибку, как в следующем случае:

string = "hello world"
string[1] = "R"

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

Перебор строки

С помощью цикла for можно перебрать все символы строки:

string = "hello world"
for char in string:
    print(char)

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

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

• string[:end]: извлекается последовательность символов начиная с 0-го индекса по индекс end (не включая)

• string[start:end]: извлекается последовательность символов начиная с индекса start по индекс end (не включая)

• string[start:end:step]: извлекается последовательность символов начиная с индекса start по индекс end (не включая) через шаг step

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

string = "hello world"

# с 0 до 5 индекса
sub_string1 = string[:5]
print(sub_string1)      # hello

# со 2 до 5 индекса
sub_string2 = string[2:5]
print(sub_string2)      # llo

# с 2 по 9 индекса через один символ
sub_string3 = string[2:9:2]
print(sub_string3)      # lowr

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

Одной из самых распространенных операций со строками является их объединение или конкатенация. Для объединения строк применяется операция сложения:

name = "Tom"
surname = "Smith"
fullname = name + " " + surname
print(fullname)  # Tom Smith

С объединением двух строк все просто, но что, если нам надо сложить строку и число? В этом случае необходимо привести число к строке с помощью функции str():

name = "Tom"
age = 33
info = "Name: " + name + " Age: " + str(age)
print(info)  # Name: Tom Age: 33

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

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

print("a" * 3)  # aaa
print("he" * 4)  # hehehehe

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

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

str1 = "1a"
str2 = "aa"
str3 = "Aa"
print(str1 > str2)  # False, так как первый символ в str1 - цифра
print(str2 > str3)  # True, так как первый символ в str2 - в нижнем регистре

Поэтому строка «1a» условно меньше, чем строка «aa». Вначале сравнение идет по первому символу. Если начальные символы обоих строк представляют цифры, то меньшей считается меньшая цифра, например, «1a» меньше, чем «2a».

Если начальные символы представляют алфавитные символы в одном и том же регистре, то смотрят по алфавиту. Так, «aa» меньше, чем «ba», а «ba» меньше, чем «ca».

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

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

Функция lower() приводит строку к нижнему регистру, а функция upper() — к верхнему.

str1 = "Tom"
str2 = "tom"
print(str1 == str2)  # False - строки не равны

print(str1.lower() == str2.lower())  # True

Функции ord и len

Поскольку строка содержит символы Unicode, то с помощью функции ord() мы можем получить числовое значение для символа в кодировке Unicode:

print(ord("A"))     # 65

Для получения длины строки можно использовать функцию len():

string = "hello world"
length = len(string)
print(length)	# 11

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

С помощью выражения term in string можно найти подстроку term в строке string. Если подстрока найдена, то выражение вернет значение True, иначе возвращается значение False:

string = "hello world"
exist = "hello" in string
print(exist)    # True

exist = "sword" in string
print(exist)    # False

НазадСодержаниеВперед

строк Python

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

Следующие строки являются допустимыми строковыми литералами в Python.

 'Это строка в Python' # строка в одинарных кавычках
"Это строка в Python" # строка в двойных кавычках
'''Это строка в Python''' # строка в тройных кавычках
"""Это строка в Python""" # строка в тройных двойных кавычках
 

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

 str1='Это строка в Python'
печать (стр1)
str2="Это строка в Python"
печать (стр2)
 

 Это строка в Python
Это строка в Python
 

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

 str1='''Это
первый
Многострочная строка.
'''
печать (стр1)

str2="""Это
второй
Многострочный
нить."""
печать (стр2)
 

 Это
первый
Многострочная строка.

Это
второй
Многострочный
нить.
 

Если строковый литерал требует включения двойных кавычек как части строки, то он должен быть заключен в одинарные кавычки. Аналогично, если строка включает одинарную кавычку как часть строки, ее следует заключить в двойные кавычки.

 str1='Добро пожаловать в "Учебник по Python" на TutorialsTeacher'
печать (стр1)

str2="Добро пожаловать в 'Учебник по Python' на TutorialsTeacher"
печать (стр2)
     

 Добро пожаловать в «Учебное пособие по Python» от TutorialsTeacher
Добро пожаловать в «Учебник по Python» на TutorialsTeacher
 

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

 >>> приветствие='Привет'
>>> лен (приветствовать)
5
 

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

 >>> приветствие='привет'
>>> поприветствовать[0]
'час'
>>> поприветствовать[1]
'е'
>>> поприветствовать[2]
'л'
>>> поприветствовать[3]
'л'
>>> поприветствовать[4]
'о'
>>> welcome[5] # выдать ошибку, если index > len(string)-1
Traceback (последний последний вызов):
Файл "", строка 1, в 
приветствовать [5]
IndexError: индекс строки вне допустимого диапазона
 

Python также поддерживает отрицательное индексирование, начиная с -(длина строки) и заканчивая -1.

 >>> приветствие='привет'
>>> поприветствовать[-5]
'час'
>>> поприветствовать[-4]
'е'
>>> поприветствовать[-3]
'л'
>>> поприветствовать[-2]
'л'
>>> поприветствовать[-1]
'о'
 

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

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

ул Класс

Все строки являются объектами класса str в Python.

 >>> приветствие='привет'
>>> типа (приветствовать)
<класс 'ул'>
 

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

 >>> ул(100)
«100»
>>> ул(-10)
'-10'
>>> ул(правда)
'Истинный'
 

Escape-последовательности

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

 str1='Добро пожаловать в \'Учебное пособие по Python\' на TutorialsTeacher'
печать (стр1)

str2="Добро пожаловать в \"Учебное пособие по Python\" на TutorialsTeacher"
печать (стр2)
     

 Добро пожаловать в «Учебное пособие по Python» от TutorialsTeacher
Добро пожаловать в «Учебник по Python» на TutorialsTeacher
 

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

 str1=r'Добро пожаловать в \'Учебное пособие по Python\' на TutorialsTeacher'
печать (стр1)
 

 Добро пожаловать в «Учебное пособие по Python» от TutorialsTeacher
 

В следующей таблице перечислены управляющие последовательности в Python.

Последовательность выхода	Описание	Пример
\\	Обратная косая черта	>>> «Привет\\Привет» Привет
\б	Backspace	>>> «ab\bc» переменный ток
\f	Подача формы
\n	Новая линия	>>> «привет\nмир» Привет мир
\nnn	Восьмеричная запись, где n находится в диапазоне 0–7.	>>> ‘\101’ А
\т	Вкладка	>>> ‘Привет\tPython’ Привет    Питон
\xnn	Шестнадцатеричная запись, где n находится в диапазоне от 0 до 9, от a до f или от A до F.	>>> ‘\x48\x69 Привет
\онн	Восьмеричная запись, где n находится в диапазоне 0–9.	>>> «\110\151» Привет

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

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

Оператор	Описание	Пример
+	Добавляет вторую строку к первой	>>> а=’привет’ >>> б=’мир’ >>> а+б ‘Привет, мир’
*	Объединяет несколько копий одной и той же строки	>>> а=’привет’ >>> а*3 ‘Здравствуйте Здравствуйте Здравствуйте’
[]	Возвращает символ по заданному индексу	>>> а = ‘Питон’ >>> а[2] т
[ : ]	Выбирает символы в диапазоне, указанном двумя операндами индекса, разделенными символом :	>>> а = ‘Питон’ >>> а[0:2] ‘Пи’
в	Возвращает true , если в данной строке существует символ.	>>> а = ‘Питон’ >>> ‘х’ в Ложь >>> ‘у’ в Правда >>> ‘p’ в ЛОЖЬ
не в	Возвращает true , если символ не существует в заданной строке	>>> а = ‘Питон’ >>> ‘x’ не в Правда >>> ‘y’ не в ЛОЖЬ

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

Метод	Описание
ул. капитализовать()	Возвращает копию строки с заглавной буквой первого символа и строчными буквами остальных букв.
string.casefold()	Возвращает строку в нижнем регистре. Он похож на метод lower(), но метод casefold() преобразует больше символов в нижний регистр.
строка.центр()	Возвращает новую центрированную строку указанной длины, дополненную указанным символом. Символ по умолчанию — пробел.
строка.количество()	Ищет (с учетом регистра) указанную подстроку в заданной строке и возвращает целое число, указывающее вхождения подстроки.
строка.заканчивается()	Возвращает True, если строка заканчивается указанным суффиксом (с учетом регистра), в противном случае возвращает False.
строка.expandtabs()	Возвращает строку, в которой все символы табуляции \t заменены одним или несколькими пробелами, в зависимости от количества символов перед \t и указанного размера табуляции.
строка.найти()	Возвращает индекс первого вхождения подстроки в заданной строке (с учетом регистра). Если подстрока не найдена, возвращается -1.
строка. индекс()	Возвращает индекс первого вхождения подстроки в заданной строке.
string.isalnum()	Возвращает True, если все символы в строке являются буквенно-цифровыми (буквами или цифрами). Если нет, возвращается False.
string.isalpha()	Возвращает True, если все символы в строке являются буквенными (как строчными, так и прописными), и возвращает False, если хотя бы один символ не является алфавитом.
строка.isascii()	Возвращает True, если строка пуста или все символы в строке ASCII.
строка.isdecimal()	Возвращает True, если все символы в строке являются десятичными. Если нет, возвращается False.
строка.isdigit()	Возвращает True, если все символы в строке являются цифрами или символами Unicode цифры. Если нет, возвращается False.
строка.идентификатор()	Проверяет, является ли строка допустимой строкой идентификатора или нет. Он возвращает True, если строка является допустимым идентификатором, в противном случае возвращает False.
строка. islower()	Проверяет, все ли символы данной строки в нижнем регистре или нет. Он возвращает True, если все символы в нижнем регистре, и False, даже если один символ в верхнем регистре.
строка.isnumeric()	Проверяет, все ли символы строки являются числовыми или нет. Он вернет True, если все символы являются числовыми, и вернет False, даже если один символ не является числовым.
строка.isprintable()	Возвращает True, если все символы данной строки являются Printable. Он возвращает False, даже если один символ является непечатаемым.
строка. isspace()	Возвращает True, если все символы заданной строки являются пробелами. Он возвращает False, даже если один символ не является пробелом.
строка.istitle()	Проверяет, является ли первый символ каждого слова прописным, а остальные строчными или нет. Он возвращает True, если строка имеет заглавный регистр; в противном случае возвращается False. Символы и цифры игнорируются.
строка.isupper()	Возвращает True, если все символы в верхнем регистре, и False, даже если один символ не в верхнем регистре.
строка. присоединиться()	Возвращает строку, которая представляет собой конкатенацию строки (для которой она вызывается) со строковыми элементами указанного итерируемого объекта в качестве аргумента.
строка.ljust()	Возвращает выровненную по левому краю строку с указанной шириной. Если указанная ширина больше длины строки, то оставшаяся часть строки заполняется указанным fillchar.
строка.нижний()	Возвращает копию исходной строки, в которой все символы преобразованы в нижний регистр.
строка.lstrip()	Возвращает копию строки, удаляя начальные символы, указанные в качестве аргумента.
строка.maketrans()	Возвращает таблицу сопоставления, которая сопоставляет каждый символ в заданной строке с символом во второй строке в той же позиции. Эта таблица сопоставления используется с методом translate(), который заменяет символы в соответствии с таблицей сопоставления.
строка.раздел()	Разбивает строку при первом появлении указанного аргумента разделителя строк и возвращает кортеж, содержащий три элемента: часть перед разделителем, сам разделитель и часть после разделителя.
строка.заменить()	Возвращает копию строки, в которой все вхождения подстроки заменены другой подстрокой.
строка.rfind()	Возвращает наивысший индекс указанной подстроки (последнее вхождение подстроки) в данной строке.
строка.rindex()	Возвращает индекс последнего вхождения подстроки в заданной строке.
строка.rjust()	Возвращает выровненную по правому краю строку с указанной шириной. Если указанная ширина больше длины строки, то оставшаяся часть строки заполняется указанным заполняющим символом.
строка.rpartition()	Разбивает строку в последнем вхождении указанного аргумента sep разделителя строк и возвращает кортеж, содержащий три элемента: часть перед разделителем, сам разделитель и часть после разделителя.
строка.rsplit()	Разделяет строку с указанным разделителем и возвращает объект списка со строковыми элементами.
строка.rstrip()	Возвращает копию строки, удаляя конечные символы, указанные в качестве аргумента.
строка.split()	Разделяет строку с указанным разделителем и возвращает объект списка со строковыми элементами.
строка.splitlines()	Разбивает строку по границам строк и возвращает список строк в строке.
строка.начинается с()	Возвращает True, если строка начинается с указанного префикса. Если нет, возвращается False.
строка.strip()	Возвращает копию строки, удаляя как начальные, так и конечные символы.
строка.свопкейс()	Возвращает копию строки с преобразованием символов верхнего регистра в нижний регистр и наоборот. Символы и буквы игнорируются.
строка.название()	Возвращает строку, в которой каждое слово начинается с символа верхнего регистра, а остальные символы — строчными.
строка.перевести()	Возвращает строку, в которой каждый символ сопоставляется с соответствующим символом в таблице перевода.
строка.верхняя()	Возвращает строку в верхнем регистре. Символы и цифры остаются неизменными.
строка.zfill()	Возвращает копию строки с символами ‘0’, дополненными слева. Он добавляет нули (0) в начало строки до тех пор, пока длина строки не станет равной указанному параметру ширины.

Введение в строки Python

Python — это высокоуровневый интерпретируемый язык программирования, разработанный в конце 1980-х годов, который за последние несколько лет получил огромное распространение. Хотя его можно использовать во многих различных приложениях, его возрождение популярности было вызвано ростом науки о данных и бизнес-аналитики. В 2018 году Python был признан самой востребованной технологией года по результатам опроса разработчиков Stack Overflow.

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

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

«Строка» — это тип данных в Python, состоящий из набора символов. Он может включать буквы, цифры и даже специальные символы. Например: «Упрощенное обучение», «Версия 1.0».

Как создать строку в Python?

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

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

1. Как создать строку

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

Пример:

Рис. Пример строк Python

2. Доступ к символам по индексу строки

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

Рис: Доступ к символу строки

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

Рис: Разрезание нити

3. Длина строки

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

Пример:

Рис: Чтобы найти длину строки

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

Термин «конкатенация» означает объединение двух строк в одну строку. Мы можем объединить две строки с помощью оператора ( + ).

Пример:

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

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

Метод split() Python разделяет заданную строку на основе определенного разделителя.

Синтаксис: str.split(‘разделитель’)

Пример:

Рис. Разделение строки

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

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

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

Строковые функции Python

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

1. format(): используется для преобразования строки фреймворка и предоставленных значений в отформатированную строку.
2. split(): чтобы разделить строку на последовательность строк в зависимости от разделителя, используйте функцию Python string split().
3. join(): Строковый объект, используемый в качестве разделителя в возвращаемом этой функцией значении, представляет собой новую строку, созданную путем объединения строк в записи.
4. upper(): функция Python str.upper() позволяет преобразовать строку в верхний регистр.
5. lower(): эта функция создает новую строчную строку.
6. replace(): функция replace() языка Python используется для создания новой строки путем замены некоторых символов в существующей строке.
7. translate(): с помощью предоставленной таблицы перевода программа Python String translate() создает новую строку для каждого элемента исходной строки.
8. count(): функция Python для подсчета строк возвращает количество раз, когда указанная подстрока появляется в заданной строке.
9. casefold(): метод casefold() строки Python возвращает дубликат строки, свернутый регистром. Используйте эту функцию для сравнения строк без учета регистра.
10. expandtabs(): метод expandtabs() в Python создает новую строку, заменяя символы табуляции (t) одним или несколькими пробелами.

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

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

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

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

Нарезка строки

Python предлагает функцию slice(), которая создает объект, называемый «срезом», который содержит набор индексов «начало» и «конец», а также значения шага. Чтобы быть более точным, переменные (начало, остановка, шаг). Этот оператор настолько гибок и синтаксически элегантен, что позволяет извлекать из строки несколько комбинаций подстрок, используя всего несколько аргументов. В программировании на Python нарезка строк — это процесс извлечения подстроки из заданной строки путем разрезания ее по индексной строке от «начала» до «конца».

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

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

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

Пример:

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

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

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

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

Цикл по строке  

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

Длина строки: длину строки можно получить с помощью функции Python String len(). Строка представляет собой группу символов, и количество символов в строке определяет ее длину.

Строковые операции Python

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

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

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

1. + : значения по обе стороны от оператора добавляются путем конкатенации.
2. * : Объединение нескольких экземпляров одной и той же строки вместе для формирования новых строк является повторением.
3. [ : ] : Отрежьте от предоставленного диапазона, чтобы получить символы.

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

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

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

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

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

Тест на принадлежность к строке

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

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

Как сравнивать строки в Python?

Равенство Python (==) и операторы сравнения (, >,!=, =, >=) используются для сравнения строк. Для сравнения двух строк не существует специальных методов. Python сравнивает каждый символ в двух строках отдельно. После обнаружения различных символов значения кодовой точки Unicode каждого символа сравниваются. Предполагается, что символ с меньшим значением Unicode меньше.

Конструктор Str()

В Python есть встроенная функция str(), которая возвращает печатное строковое представление любого объекта.

Пример:

Рис. Преобразование любого типа данных в строку Python

Escape-последовательность Python

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

Рис: Синтаксическая ошибка

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

Пример:

Рис: последовательность обратной косой черты строки Python

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

Рис. Некоторые полезные управляющие последовательности

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

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

• Заглавная буква()

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

Синтаксис: строка. капитализировать()

Пример:

Рис: метод capitalize()

• Раздевание()

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

Синтаксис: string.strip()

Пример:

Рис: метод strip()

• Нижний()

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

Пример:

Рис: метод lower()

• Верхний()

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

Пример:

Рис: метод upper()

• Заменить()

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

Пример:

Рис: метод replace()

Если вы хотите получить навыки, необходимые для работы в сложной, полезной и динамичной роли в сфере ИТ, мы вас поддержим! Откройте для себя бесконечные возможности с помощью этой инновационной программы для аспирантов по курсу Full Stack Web Development, разработанному нашими партнерами из Caltech CTME.

No related posts.