Python string methods

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

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

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

Регулярное выражение ‘\d +’ соответствует одной или нескольким десятичным цифрам. В этом примере мы будем использовать это регулярное выражение для разделения строки на фрагменты, разделенные одной или несколькими десятичными цифрами.

import re

#a string
str = 'foo635bar4125mango2apple21orange'
#split with regular expression
chunks = re.split('\d+',str)
print(chunks)

Вывод:

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

В этом руководстве мы узнаем, как разделить строку пробелом в Python с помощью методов String.split() и re.split().

В этом примере мы возьмем строку, содержащую слова, элементы или фрагменты, разделенные пробелом. Затем мы разделим строку по пробелу с помощью метода String.split(), который возвращает список.

str = '63 41 92 81 69 70'

#split string by single space
chunks = str.split(' ')

print(chunks)

Вывод:

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

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

Оператор %

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

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

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

1. ‘%d’, ‘%i’, ‘%u – десятичное число;
2. ‘%c’ – символ, точнее строка из одного символа или число – код символа;
3. ‘%r’ – строка (литерал Python);
4. ‘%s’ – строка.

Такой способ форматирования строк называет «старым» стилем, который в Python 3 был заменен на более удобные способы.

str.format()

В Python 3 появился более новый метод форматирования строк, который вскоре перенесли и в Python 2.7. Такой способ избавляет программиста от специального синтаксиса %-оператора. Делается все путем вызова .format() для строковой переменной. С помощью специального символа – фигурных скобок – указывается место для подстановки значения, каждая пара скобок указывает отдельное место для подстановки, значения могут быть разного типа:

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

f-строки (Python 3.6+)

В Python версии 3.6 появился новый метод форматирования строк – «f-строки», с его помощью можно использовать встроенные выражения внутри строк:

Такой способ форматирования очень мощный, так как дает возможность встраивать выражения:

Таким образом, форматирование с помощью f-строк напоминает использование метода format(), но более гибкое, быстрое и читабельное.

Стандартная библиотека Template Strings

Еще один способ форматирования строк, который появился еще с выходом Python версии 2.4, но так и не стал популярным – использование библиотеки Template Strings. Есть поддержка передачи значения по имени, используется $-синтаксис как в языке PHP:

Мир регулярных выражений

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

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

Разделение по шаблону:

import re
test_punctuation = "  This &is  example? {of} string. with.? punctuation!!!!  "
re.split('\W+', test_punctuation)

Out: 

Замена по шаблону:

import re
test_with_numbers = "This is 1 string with 10 words for 9 digits 2 example"
re.sub('\d', '*', test_with_numbers)

Out: 'This is * string with ** words for * digits * example'

Строки нарезки в Python – примеры

Струны нарезки Python могут быть сделаны по-разному.

Обычно мы получаем доступ к строковым элементам (символам) с помощью простой индексации, которая начинается с до N-1 (n – длина строки). Следовательно, для доступа к 1-й Элемент строки Мы можем просто использовать код ниже.

s1 = String1

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

s1 = String1

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

1. Строки нарезки в Python с началом и концом

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

#string slicing with two parameters
s = "Hello World!"

res1 = s
res2 = s #using negative indexing

print("Result1 = ",res1)
print("Result2 = ",res2)

Выход :

Result1 =  llo Wo
Result2 =  rld

Здесь,

• Мы инициализируем строку, как “Привет мир!” ,
• Сначала мы нарезаем данную строку с начальным индексом 2 и окончание индекса как 8 Отказ Это означает, что результирующая подконта будет содержать символы из S к S ,
• Аналогично, для следующего, результирующая подкора должна содержать символы из S к S Отказ

Следовательно, наш выход оправдан.

2. Струки срез, используя только начало или конец

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

#string slicing with one parameter
s1= "Charlie"
s2="Jordan"

res1 = s1 #default value of ending position is set to the length of string
res2 = s2 #default value of starting position is set to 0

print("Result1 = ",res1)
print("Result2 = ",res2)

Выход :

Result1 =  arlie
Result2 =  Jord

Здесь,

Сначала инициализируем две строки, S1 и S2 , Для нарезки их обоих мы просто упомяну о start_pos Для S1 и End_Pos только для S2, Следовательно, для RES1 , он содержит подконтную строку S1 из индекса 2 (как упоминалось) до последнего (по умолчанию он устанавливается на N-1)

Принимая во внимание, что для RES2 диапазон индексов лежит от 0 до 4 (упомянутых).

3. Строки нарезки в Python со ступенчатым параметром

Значение решает прыжок операции нарезки займет из одного индекса к другому. Посмотрите на пример ниже.

#string slicing with step parameter
s= "Python"
s1="Kotlin"

res = s
res1 = s1 #using negative parameters

print("Resultant sliced string = ",res)
print("Resultant sliced string(negative parameters) = ",res1)

Выход :

Resultant sliced string =  Pto
Resultant sliced string(negative parameters) =  nl

В коде выше,

• Мы инициализируем две строки S и S1 и попытайтесь нарезать их за данные начальные и окончательные индексы, как мы сделали для нашего первого примера,
• Но на этот раз мы упомянули шаг значение, которое было установлено на 1 по умолчанию для предыдущих примеров,
• Для RES, имеющих размер шага 2 означает, что, в то время как прохождение для получения подстроки от индекса от 0 до 4, каждый раз, когда индекс будет увеличен по значению 2. То есть первый символ S («P») следующие символы в подпологе будут S и S до тех пор, пока индекс не будет меньше 5.
• Для следующего я. RES1 Упомянутый шаг (-2). Следовательно, похоже на предыдущий случай, персонажи в подстроке будут S1 Тогда S1 или S1 до тех пор, пока индекс не будет меньше (-4).

4. Реверсируя строку с помощью нарезки в Python

С использованием отрицательной индексной строки нарезки в Python мы также можем поменять строку и хранить ее в другой переменной. Для этого нам просто нужно упомянуть Размер (-1) Отказ

Давайте посмотрим, как это работает в приведенном ниже примере.

#reversing string using string slicing
s= "AskPython"
rev_s = s #reverse string stored into rev_s

print(rev_s)

Выход :

nohtyPksA

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

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

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

Python

# -*- coding: utf-8 -*-

my_string = «Я люблю %s» % «Python»
print(my_string) # Я люблю Python

var = «яблоки»
newString = «Я ем %s» % var
print(newString) # Я ем яблоки

another_string = «Я люблю %s и %s» % («Python», var)
print(another_string) # Я люблю Python и яблоки

1 2 3 4 5 6 7 8 9 10 11

# -*- coding: utf-8 -*-   my_string=»Я люблю %s»%»Python» print(my_string)# Я люблю Python var=»яблоки» newString=»Я ем %s»%var print(newString)# Я ем яблоки another_string=»Я люблю %s и %s»%(«Python»,var) print(another_string)# Я люблю Python и яблоки

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

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

Python

another_string = «Я люблю %s и %s» % «Python»

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: not enough arguments for format string

1 2 3 4 5

another_string=»Я люблю %s и %s»%»Python» Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErrornotenough arguments forformatstring

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

Python

my_string = «%i + %i = %i» % (1,2,3)
print(my_string) # ‘1 + 2 = 3’

float_string = «%f» % (1.23)
print(float_string) # ‘1.230000’

float_string2 = «%.2f» % (1.23)
print(float_string2) # ‘1.23’

float_string3 = «%.2f» % (1.237)
print(float_string3) # ‘1.24’

1 2 3 4 5 6 7 8 9 10 11

my_string=»%i + %i = %i»%(1,2,3) print(my_string)# ‘1 + 2 = 3’ float_string=»%f»%(1.23) print(float_string)# ‘1.230000’ float_string2=»%.2f»%(1.23) print(float_string2)# ‘1.23’ float_string3=»%.2f»%(1.237) print(float_string3)# ‘1.24’

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

Обратите внимание на то, что результат включает множество дополнительных нулей (1.230000). Нам это не нужно, так что мы указываем Python ограничить выдачу до двух десятичных значений в третьем примере (“%.2f”)

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

Python

int_float_err = «%i + %f» % («1», «2.00»)
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: %d format: a number is required, not str

1 2 3 4

int_float_err=»%i + %f»%(«1″,»2.00») Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeError%dformatanumber isrequired,notstr

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

Python

int_float_err = «%i + %f» % (1, «2.00»)

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: float argument required, not str

1 2 3 4 5

int_float_err=»%i + %f»%(1,»2.00″) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErrorfloatargument required,notstr

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

“Старая-школа” форматирования строк в Python

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

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

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

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

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

>>> 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.'

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

Вариант #2: str.format()

Этот новый способ вывода строк был представлен в Python 2.6. Вы можете обратиться к для получения дополнительной информации.

Как используется str.format()

str.format() — это улучшение % — форматирования. Он использует обычный синтаксис вызова функции и метода __format__() для объекта, преобразуемого в строку.

С помощью str.format() поля вывода переменных отмечены фигурными скобками:

>>> "Hello, {}. You are {}.".format(name, age)
'Hello, Eric. You are 74.'

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

>>> "Hello, {1}. You are {0}.".format(age, name)
'Hello, Eric. You are 74.'

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

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(name=person, age=person)
'Hello, Eric. You are 74.'

Вы также можете использовать символ **, чтобы использовать этот трек со словарями:

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(**person)
'Hello, Eric. You are 74.'

str.format() определенно является улучшением по сравнению с % — форматированием, но и у него есть свои недостатки.

В чем недостатки str.format()

Код, использующий 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.'

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

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

capitalize()	Преобразует первый символ строки в верхний регистр	str_name.capitalize()
casefold()	Он преобразует любую строку в нижний регистр независимо от ее регистра	str_name.casefold()
center()	Используется для выравнивания строки по центру	str_name.center (длина, символ)
count()	Для подсчета количества раз, когда определенное значение появляется в строке.	str_name.count (значение, начало, конец)
endswith()	Проверяет, заканчивается ли строка указанным значением, затем возвращает True	str_name.endswith (значение, начало, конец)
find()	Используется для определения наличия указанного значения в строке	str_name.find (значение, начало, конец)
index()	Он используется для поиска первого вхождения указанного значения в строке	str_name.index (значение, начало, конец)
isalnum()	Проверяет, все ли символы являются буквенно-цифровыми, затем возвращает True	str_name.isalnum()
isalpha()	Проверяет, все ли символы являются алфавитными (az), затем возвращает True	str_name.isalpha()
isdecimal()	Проверяет, все ли символы являются десятичными (0-9), затем возвращает True	str_name.isdecimal()
isdigit()	Проверяет, все ли символы являются цифрами, затем возвращает True	str_name.isdigit()
islower()	Проверяет, все ли символы в нижнем регистре, затем возвращает True	str_name.islower()
isnumeric()	Проверяет, все ли символы являются числовыми (0-9), затем возвращает True	str_name.isnumeric()
isspace()	Проверяет, все ли символы являются пробелами, затем возвращает True	str_name.isspace()
isupper()	Проверяет, все ли символы в верхнем регистре, затем возвращает True	str_name.isupper()
lower()	Используется для преобразования всех символов в нижний регистр	str_name.lower()
partition()	Используется для разделения строки на кортеж из трех элементов.	str_name.partition (значение)
replace()	Используется для замены указанного слова или фразы другим словом или фразой в строке.	str_name.replace (старое значение, новое значение, количество)
split()	Используется для разделения строки на список	str_name.split (разделитель, maxsplit)
splitlines()	Используется для разделения строки и составления ее списка. Разбивается на разрыв строки.	str_name.splitlines (keeplinebreaks)
startswith()	Проверяет, начинается ли строка с указанного значения, затем возвращает True	str_name.startswith (значение, начало, конец)
strip()	Используется для удаления символов, указанных в аргументе, с обоих концов	str_name.strip (символы)
swapcase()	Используется для замены строки верхнего регистра на нижний регистр или наоборот.	str_name.swapcase()
title()	Преобразует начальную букву каждого слова в верхний регистр	str_name.title()
upper()	Он используется для преобразования всех символов в строке в верхний регистр	str_name.upper()

Python splitting and joining strings

A string can be split with the or the
method. They return a list of strings which
were cut from the string using a separator. The optional second
parameter is the maximum splits allowed.

splitting.py

#!/usr/bin/env python

# splitting.py

nums = "1,5,6,8,2,3,1,9"

k = nums.split(",")
print(k)

l = nums.split(",", 5)
print(l)

m = nums.rsplit(",", 3)
print(m)

We have a comma-delimited string. We cut the string into parts.

k = nums.split(",")

We split the string into eight parts using a comma as a separator.
The method returns a list of eight strings.

l = nums.split(",", 5)

Here we split the string into six parts. There are five substrings
and the remainder of the string.

m = nums.rsplit(",", 3)

Here we split the string into four parts. This time the splitting goes
from the right.

$ ./splitting.py

Strings can be joined with the string.
It returns a string concatenated from the strings passed as a parameter.
The separator between elements is the string providing this method.

split_join.py

#!/usr/bin/env python

# split_join.py

nums = "1,5,6,8,2,3,1,9"

n = nums.split(",")
print(n)

m = ':'.join(n)
print(m)

First we split a string into a list of strings. Then we
join the strings into one string with the elements being
separated by the provided character.

m = ':'.join(n)

The method creates one string from a list of
strings. The elements are separated by the character.

$ ./split_join.py

1:5:6:8:2:3:1:9

This is the output.

Another method which can be used for splitting strings is .
It will split the string at the first occurrence of the separator and return
a 3-tuple containing the part before the
separator, the separator itself, and the part after the separator.

partition.py

#!/usr/bin/env python

# partition.py

s = "1 + 2 + 3 = 6"

a = s.partition("=")

print(a)

We use the method in this example.

a = s.partition("=")

This will cut the string into three parts. One before the
character, the separator, and the right side after the separator.

$ ./partition.py
('1 + 2 + 3 ', '=', ' 6')

This is the output.

Escape Characters

Following table is a list of escape or non-printable characters that can be represented with backslash notation.

An escape character gets interpreted; in a single quoted as well as double quoted strings.

Backslash notation	Hexadecimal character	Description
\a	0x07	Bell or alert
\b	0x08	Backspace
\cx		Control-x
\C-x		Control-x
\e	0x1b	Escape
\f	0x0c	Formfeed
\M-\C-x		Meta-Control-x
\n	0x0a	Newline
\nnn		Octal notation, where n is in the range 0.7
\r	0x0d	Carriage return
\s	0x20	Space
\t	0x09	Tab
\v	0x0b	Vertical tab
\x		Character x
\xnn		Hexadecimal notation, where n is in the range 0.9, a.f, or A.F

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

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

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

string = "hello world"
c0 = string  # h
print(c0)
c6 = string  # w
print(c6)

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

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

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

string = "hello world"
c1 = string  # d
print(c1)
c5 = string  # w
print(c5)

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

string = "hello world"
string = "R"

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

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

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

• : извлекается последовательность символов начиная с 0-го индекса по индекс end

• : извлекается последовательность символов начиная с индекса start по индекс end

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

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

string = "hello world"

# с 0 до 5 символа
sub_string1 = string
print(sub_string1)      # hello

# со 2 до 5 символа
sub_string2 = string
print(sub_string2)      # llo

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

Функции ord и len

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

print(ord("A"))     # 65

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

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

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

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

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

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

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

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

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

НазадВперед

Вводная информация о строках

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

Литералы строк

Литерал – способ создания объектов, в случае строк Питон предлагает несколько основных вариантов:

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

Разницы между строками с одинарными и двойными кавычками нет – это одно и то же

Какие кавычки использовать – решать вам, соглашение PEP 8 не дает рекомендаций по использованию кавычек. Просто выберите один тип кавычек и придерживайтесь его. Однако если в стоке используются те же кавычки, что и в литерале строки, используйте разные типы кавычек – обратная косая черта в строке ухудшает читаемость кода.

Кодировка строк

В третьей версии языка программирования Python все строки представляют собой последовательность Unicode-символов.

В Python 3 кодировка по умолчанию исходного кода – UTF-8. Во второй версии по умолчанию использовалась ASCII. Если необходимо использовать другую кодировку, можно разместить специальное объявление на первой строке файла, к примеру:

Максимальная длина строки в Python

Максимальная длина строки зависит от платформы. Обычно это:

• 2**31 — 1 – для 32-битной платформы;
• 2**63 — 1 – для 64-битной платформы;

Константа , определенная в модуле

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

Одна из самых распространенных операций со строками – их объединение (конкатенация). Для этого используется знак , в результате к концу первой строки будет дописана вторая:

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

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

При сравнении нескольких строк рассматриваются отдельные символы и их регистр:

• цифра условно меньше, чем любая буква из алфавита;
• алфавитная буква в верхнем регистре меньше, чем буква в нижнем регистре;
• чем раньше буква в алфавите, тем она меньше;

При этом сравниваются по очереди первые символы, затем – 2-е и так далее.

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

Как удалить строку в Python

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

Или перезаписать переменную пустой строкой:

Обращение по индексу

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

Индекс начинается с 0

В Python предусмотрена возможность получить доступ и по отрицательному индексу. В таком случае отсчет будет вестись от конца строки: