Как изменить регистр строки питон

I have problem in changing a string into uppercase with Python. In my research, I got string.ascii_uppercase but it doesn't work. The following code: >>s = 'sdsd' >>s.ascii_uppercase

I have problem in changing a string into uppercase with Python. In my research, I got string.ascii_uppercase but it doesn’t work.

The following code:

 >>s = 'sdsd'
 >>s.ascii_uppercase

Gives this error message:

Traceback (most recent call last):
  File "<console>", line 1, in <module>
AttributeError: 'str' object has no attribute 'ascii_uppercase'

My question is: how can I convert a string into uppercase in Python?

Kai - Kazuya Ito's user avatar

asked Feb 13, 2012 at 7:48

gadss's user avatar

2

Use str.upper():

>>> s = 'sdsd'
>>> s.upper()
'SDSD'

See String Methods.

Tomerikoo's user avatar

Tomerikoo

17.6k16 gold badges41 silver badges59 bronze badges

answered Feb 13, 2012 at 7:51

Dan D.'s user avatar

Dan D.Dan D.

72.3k14 gold badges101 silver badges122 bronze badges

4

To get upper case version of a string you can use str.upper:

s = 'sdsd'
s.upper()
#=> 'SDSD'

On the other hand string.ascii_uppercase is a string containing all ASCII letters in upper case:

import string
string.ascii_uppercase
#=> 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

answered Feb 13, 2012 at 7:56

KL-7's user avatar

KL-7KL-7

45k9 gold badges86 silver badges74 bronze badges

to make the string upper case — just simply type

s.upper()

simple and easy! you can do the same to make it lower too

s.lower()

etc.

answered Jun 27, 2016 at 15:50

Katie T's user avatar

Katie TKatie T

3412 silver badges6 bronze badges

s = 'sdsd'
print (s.upper())
upper = raw_input('type in something lowercase.')
lower = raw_input('type in the same thing caps lock.')
print upper.upper()
print lower.lower()

Community's user avatar

answered Jul 16, 2014 at 0:49

H CODE's user avatar

H CODEH CODE

1991 silver badge2 bronze badges

1

for making uppercase from lowercase to upper
just use

"string".upper()

where "string" is your string that you want to convert uppercase

for this question concern it will like this:

s.upper()

for making lowercase from uppercase string
just use

"string".lower()

where "string" is your string that you want to convert lowercase

for this question concern it will like this:

s.lower()

If you want to make your whole string variable use

s="sadf"
# sadf

s=s.upper()
# SADF

Keyur Potdar's user avatar

Keyur Potdar

7,0896 gold badges25 silver badges40 bronze badges

answered Sep 1, 2016 at 16:36

Pawanvir singh's user avatar

For questions on simple string manipulation the dir built-in function comes in handy. It gives you, among others, a list of methods of the argument, e.g., dir(s) returns a list containing upper.

answered Oct 15, 2018 at 22:28

bartfrenk's user avatar

bartfrenkbartfrenk

1033 silver badges4 bronze badges

For converting first letter of each word into capital in a sentence

s = 'this is a sentence'

str.title(s)

>>> 'This Is A Sentence'

answered Sep 14, 2021 at 5:58

coderina's user avatar

coderinacoderina

1,44511 silver badges19 bronze badges

You can use capitalize() to make the 1st letter uppercase as shown below:

test = "this is a sentence."

print(test.capitalize()) # Here

Output:

This is a sentence.

answered Dec 15, 2022 at 13:54

Kai - Kazuya Ito's user avatar

I have problem in changing a string into uppercase with Python. In my research, I got string.ascii_uppercase but it doesn’t work.

The following code:

 >>s = 'sdsd'
 >>s.ascii_uppercase

Gives this error message:

Traceback (most recent call last):
  File "<console>", line 1, in <module>
AttributeError: 'str' object has no attribute 'ascii_uppercase'

My question is: how can I convert a string into uppercase in Python?

Kai - Kazuya Ito's user avatar

asked Feb 13, 2012 at 7:48

gadss's user avatar

2

Use str.upper():

>>> s = 'sdsd'
>>> s.upper()
'SDSD'

See String Methods.

Tomerikoo's user avatar

Tomerikoo

17.6k16 gold badges41 silver badges59 bronze badges

answered Feb 13, 2012 at 7:51

Dan D.'s user avatar

Dan D.Dan D.

72.3k14 gold badges101 silver badges122 bronze badges

4

To get upper case version of a string you can use str.upper:

s = 'sdsd'
s.upper()
#=> 'SDSD'

On the other hand string.ascii_uppercase is a string containing all ASCII letters in upper case:

import string
string.ascii_uppercase
#=> 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

answered Feb 13, 2012 at 7:56

KL-7's user avatar

KL-7KL-7

45k9 gold badges86 silver badges74 bronze badges

to make the string upper case — just simply type

s.upper()

simple and easy! you can do the same to make it lower too

s.lower()

etc.

answered Jun 27, 2016 at 15:50

Katie T's user avatar

Katie TKatie T

3412 silver badges6 bronze badges

s = 'sdsd'
print (s.upper())
upper = raw_input('type in something lowercase.')
lower = raw_input('type in the same thing caps lock.')
print upper.upper()
print lower.lower()

Community's user avatar

answered Jul 16, 2014 at 0:49

H CODE's user avatar

H CODEH CODE

1991 silver badge2 bronze badges

1

for making uppercase from lowercase to upper
just use

"string".upper()

where "string" is your string that you want to convert uppercase

for this question concern it will like this:

s.upper()

for making lowercase from uppercase string
just use

"string".lower()

where "string" is your string that you want to convert lowercase

for this question concern it will like this:

s.lower()

If you want to make your whole string variable use

s="sadf"
# sadf

s=s.upper()
# SADF

Keyur Potdar's user avatar

Keyur Potdar

7,0896 gold badges25 silver badges40 bronze badges

answered Sep 1, 2016 at 16:36

Pawanvir singh's user avatar

For questions on simple string manipulation the dir built-in function comes in handy. It gives you, among others, a list of methods of the argument, e.g., dir(s) returns a list containing upper.

answered Oct 15, 2018 at 22:28

bartfrenk's user avatar

bartfrenkbartfrenk

1033 silver badges4 bronze badges

For converting first letter of each word into capital in a sentence

s = 'this is a sentence'

str.title(s)

>>> 'This Is A Sentence'

answered Sep 14, 2021 at 5:58

coderina's user avatar

coderinacoderina

1,44511 silver badges19 bronze badges

You can use capitalize() to make the 1st letter uppercase as shown below:

test = "this is a sentence."

print(test.capitalize()) # Here

Output:

This is a sentence.

answered Dec 15, 2022 at 13:54

Kai - Kazuya Ito's user avatar

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

Содержание

  1. Строковые операторы
  2. Оператор сложения строк +
  3. Оператор умножения строк *
  4. Оператор принадлежности подстроки in
  5. Встроенные функции строк в python
  6. Индексация строк
  7. Форматирование строки
  8. Изменение строк
  9. Встроенные методы строк в Python
  10. Изменение регистра строки
  11. Найти и заменить подстроку в строке
  12. Классификация строк
  13. Выравнивание строк, отступы
  14. Методы преобразования строки в список

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

Операторы «+» и «*» в Питоне применимы не только к числам, но и к строкам.

Оператор сложения строк +

Оператор «+» выполняет операцию, называемую конкатенацией, — объединение строк.

Пример:


var_1 = 'Привет,'
var_2 = 'Python!'
print(var_1 + ' ' + var_2)
# Вывод:

Привет, Python!

Можно и так:


var_1 = 'Привет, '
var_2 = 'Python!'
var_1 += var_2
print(var_1)
# Вывод:

Привет, Python!

Оператор умножения строк *

Оператор «*» дублирует строку указанное количество раз.

Пример:


var_1 = 'O_o '
var_2 = 10
print(var_1 * var_2)
# Вывод:

O_o O_o O_o O_o O_o O_o O_o O_o O_o O_o

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


var_1 = 'O_o'
[print('При множителе', i, 'получаем строку: "' + var_1 * i + '"') for i in range(-1, 2)]
# Вывод:

При множителе -1 получаем строку: ""

При множителе 0 получаем строку: ""

При множителе 1 получаем строку: "O_o"

Оператор принадлежности подстроки in

Если надо проверить, содержится ли подстрока в строке, удобно пользоваться оператором “in”


var_1 = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit. Id,
fuga, earum consequuntur magni accusamus nihil ipsum qui. Facere,
error velit possimus qui dolorum dolorem illum voluptates nemo pariatur ea. Temporibus.
'''
print('ipsum' in var_1)
# Вывод:

True

Так же можно использовать этот оператор с «not» для инвертирования результата.


var_1 = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit. Id,
fuga, earum consequuntur magni accusamus nihil ipsum qui. Facere,
error velit possimus qui dolorum dolorem illum voluptates nemo pariatur ea. Temporibus.
'''
print('тру-ля-ля' not in var_1)
# Вывод:

True

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

Пайтон содержит ряд удобных встроенных функций для работы со строками.

Функция ord() возвращает числовое значение символа, при чём, как для кодировки ASCII, так и для UNICODE.


print('A', ord('A'))
print('А русская', ord('А'))
print('~', ord('~'))
print('1', ord('1'))  # Обратите внимание, что здесь единица является именно строкой
# Вывод:

A 65

А русская 1040

~ 126

1 49

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


from random import randint

for i in range(10):
[print(chr(randint(0, 8000)), end=' ') for i in range(10)]
print('')
# Вывод:

૸ ச ઘ ᔝ ዱ છ ᐝ § ඗ ֹ

ၹ ሌ ᔭ ཋ ٺ ຝ ྅ ᒊ ֚ ᴠ

д ߀ Ỽ Ů ጼ ̼ ᅌ ᶥ ḿ ᇶ

ᴗ ȹ ཱི ๤ ൉ ᥈ Ҥ Р ᇑ ਴

ސ ਋ ϯ ኊ ᠻ ដ ࡯ ᄖ ᓣ ᆧ

ଯ ᑟ ߂ ޸ ൢ ԝ ᤵ ඡ ᴼ ႊ

ᥒ ᜭ ˽ ä ؑ ૧ ᅈ ഉ ौ ଦ

ᔚ ॓ ௵ ᥰ ɵ ຘ Ἵ ৓ ᨃ ང

ᬇ ᳓ ᕈ ᳖ ૓ ࣝ ˼ ʋ ં გ

? ᓀ ځ ื ᚢ Ӌ ဃ ᡹ ؅ ႔

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


from random import randint

for i in range(10):
var = [chr(randint(500, 800)) for i in range(randint(10, 20))]
print(len(''.join(var)), ''.join(var))
# Вывод:

11 ˫ʸɹʄˈȺȨȪȍʮ˴

16 ȷ˝ȁɚ˷Ⱥʾ̂ʨʗȍɺɹ˫̓ȼ

13 əʼɒȞʪɗʍ̍ˡɮɫȉʙ

10 ʜ˧ˬɆ˃əȃ̚ʰ̏

12 ˤ˾ʀɨȷˌɏʿɴȨ˲ȟ

13 ˌʡ˝ȭʪɈ˾ʵȋɎʋ˿ʍ

13 ˜̃ȱ̇ˋ˂ʡȞȍ̄ʭȌʣ

14 ̙ɸɎˈ̀ȾȠ˞ȒɇʀɈȁȫ

20 ȞȎʯɐʪəʔȆʳȨɦʚ˾Ǵȁɕˋ˘̈˭

12 ʷɱ̄˺ʽʤɳȂȗʍˉɦ

 Функция str() возвращает строковое представление объекта.


from math import inf, e, pi

print(str(...))
print(str(inf))
print(str(e))
print(str(pi))
print(str(10 + 11))
print(str(10 + 11j))
print(str(None))
print(str(1 == 1))
# Вывод:

Ellipsis

inf

2.718281828459045

3.141592653589793

21

(10+11j)

None

True

Индексация строк

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


var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[0])
print(var[10])
print(var[33])
# Вывод:

L

m

c

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


var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[330])
# Вывод:

Traceback (most recent call last):

File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 7, in <module>

print(var[330])

IndexError: string index out of range

 

Process finished with exit code 1

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


var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[-1])
print(var[-10])
print(var[-33])
# Вывод:

.

t

s

Срезы строк

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


var = '''Lorem ipsum dolor sit amet, consectetur adipisicing elit.
Consequuntur, eligendi, aperiam, consequatur, perferendis
non sequi voluptates asperiores soluta quam ad id beatae
facere aut quod libero dignissimos inventore nesciunt commodi.'''
print(var[-1: 50: -3])
print(var[10:-160])
print(var[::-33])
# Вывод:

.ootieetv msg elo ara   ea   ual rrssauvuso   snee,tqn ae dgernqn    i

m dolor sit amet, consectetur adipisicing elit.

Consequuntur, eligendi, aperiam, co

.s r a n

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

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

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

Чтобы это сделать с помощью f-строки необходимо:

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

var = 10 * 254 // 77 % 5 ** 5
var_2 = f'Вот что получилось {var}'
print(var_2)
# Вывод:

Вот что получилось 32

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

Тип данных строка в Python относится к неизменяемым (immutable), но это почти не влияет на удобство их использования, ведь можно создать изменённую копию. Для этого есть два возможных пути:

  • Использовать перезапись значения переменной

var = 'Что-то '
var += 'и что-то ещё'
print(var)
var = var[:16] + 'новое'
print(var)
# Вывод:

Что-то и что-то ещё

Что-то и что-то новое

  • Использовать встроенный метод replace(x, y):

var = 'Что-то '
print(var.replace('то ', 'нибудь'))
print(var)
# Вывод:

Что-нибудь

Что-то

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

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

Поскольку строка в Пайтон – это объект, у него есть свои методы. Методы – это те же самые функции, просто они «закреплены» за объектами определённого класса.

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

Если Вам надо изменить регистр строки, удобно использовать один из следующих методов

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


var = 'abracadabra'
print(var.capitalize())
print(var)
# Вывод:

Abracadabra

abracadabra

Не алфавитные символы не изменяются:


var = '_abracadabra'
print(var.capitalize())
print(var)
# Вывод:

_abracadabra

_abracadabra

lower() преобразует все буквенные символы в строчные.


var = 'AbRaCAdAbRa'
print(var.lower())
print(var)
# Вывод:

abracadabra

AbRaCAdAbRa

swapcase() меняет регистр на противоположный.


var = 'AbRaCAdAbRa'
print(var.swapcase())
print(var)
# Вывод:

aBrAcaDaBrA

AbRaCAdAbRa

title() преобразует первые буквы всех слов в заглавные


var = 'я пРосТо ПРИМЕР'
print(var.title())
var = 'я @странный _ПРИМЕР'
print(var.title())
print(var)
# Вывод:

Я Просто Пример

Я @Странный _Пример

я @странный _ПРИМЕР

upper() преобразует все буквенные символы в заглавные.


var = 'я пРосТо ПРИМЕР'
print(var.upper())
var = 'я @странный _ПРИМЕР'
print(var.upper())
print(var)
# Вывод:

Я ПРОСТО ПРИМЕР

Я @СТРАННЫЙ _ПРИМЕР

я @странный _ПРИМЕР

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

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

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

count() подсчитывает количество точных вхождений подстроки в строку.


var = 'Ололо'
print(var.count('ол'))
# Вывод:

1

endswith() определяет, заканчивается ли строка заданной подстрокой.


var = 'Олололололо'
print(var.endswith('оло'))
print(var.endswith('ол', 5, 10))
# Вывод:

True

True

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


var = 'Олололололо'
print(var.find('оло'))
print(var.find('лОл'))
# Вывод:

2

-1

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

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


var = 'Олололололо'
print(var.index('лОл'))
# Вывод:

Traceback (most recent call last):

File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 3, in <module>

print(var.index('лОл'))

ValueError: substring not found

 

Process finished with exit code 1

rfind() ищет в строке заданную подстроку, начиная с конца.

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


var = 'Олололололо'
print(var.rfind('оло'))
# Вывод:

8

rindex() ищет в строке заданную подстроку, начиная с конца.

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

startswith() определяет, начинается ли строка с заданной подстроки.


var = 'Олололололо'
print(var.startswith('Оло'))
# Вывод:

True

Классификация строк

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

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


var = 'Олололололо'
print(var.isalnum())
# Вывод:

True

isalpha() определяет, состоит ли строка только из букв.

isdigit() определяет, состоит ли строка из цифр.

isidentifier() определяет, является ли строка допустимым идентификатором (название переменной, функции, класса и т.д.) Python.


var = 'print'
print(var.isidentifier())
# Вывод:

True

isidentifier() вернет True для строки, которая соответствует зарезервированному ключевому слову Пайтон, даже если его нельзя использовать.

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

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

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

isprintable() определяет, состоит ли строка только из печатаемых символов.


print('qwerty'.isidentifier())
print(chr(7).isidentifier())
# Вывод:

True

False

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

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

Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:

‘f’ и ‘r’ являются escape-последовательностями для символов ASCII; ‘u2005’ это escape-последовательность для Unicode.

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

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

Выравнивание строк, отступы

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

center() выравнивает строку по центру.


print('qwerty'.center(50))
print((' ' * 22 + 'qwerty' + ' ' * 22))
print((' ' * (25 - int(len('qwerty') / 2)) + 'qwerty' + ' ' * (25 - int(len('qwerty') / 2)) == ('qwerty'.center(50))))
# Вывод:

                       qwerty                      
                       qwerty                      
True

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


print('qwerty'.center(50, '='))
# Вывод:

======================qwerty======================

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


print('qwerty'.center(6, '='))
# Вывод:

qwerty

expandtabs()  заменяет каждый символ табуляции (‘t’) пробелами. По умолчанию табуляция заменяются на 8 пробелов.

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

ljust() выравнивание по левому краю.

lstrip() удаляет переданные в качестве аргумента символы слева. По умолчанию это пробелы.


print('__init__.py'.lstrip('_'))
# Вывод:

init__.py

replace() заменяет вхождения подстроки в строке.


var = 'Hello, C! Hello, JS! Hello, Python!'
print(var.replace('C', 'PHP'))
# Вывод:

Hello, PHP! Hello, JS! Hello, Python!

Необязательный аргумент count, указывает количество замен, которое нужно осуществить:


var = 'Hello, C! Hello, JS! Hello, Python!'
print(var.replace('Hello', 'Bye', 2))
# Вывод:

Bye, C! Bye, JS! Hello, Python!

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

rstrip() обрезает пробельные символы.

strip() удаляет символы с левого и правого края строки.

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


var = 'Hello, C! Hello, JS! Hello, Python!'
print(var.replace('Hello', 'Buy', 2).center(60).swapcase())
# Вывод:

              bUY, c! bUY, js! hELLO, pYTHON!               

zfill()  возвращает копию строки дополненную нулями слева для достижения длины строки указанной в параметре width:


var = 12/100*(-0.5)

print(str(var).zfill(7))
# Вывод:

-000.06

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


var = 10/3
print(str(var).zfill(7))
# Вывод:

3.3333333333333335

Методы преобразования строки в список

Методы в данной группе превращают строку в другой тип данных и наоборот. Эти методы возвращают или принимают коллекции (чаще всего это список).

join() возвращает строку, которая является результатом конкатенации элементов коллекции и разделителя.


var: list[str] = ['1', '2', '3']
print('+'.join(var))
var: tuple[str, str, str] = ('1', '2', '3')
print(' & '.join(var))
var: set[str, str, str] = {'1', '2', '3'}
print(' и '.join(var))
var: dict[str, int] = {'1': 4, '2': 5, '3': 6}
print('->'.join(var))
# Вывод:

1+2+3

1 & 2 & 3

3 и 2 и 1

1->2->3

Стоит обратить внимание что все элементы итерируемого объекта должны быть строкового типа. Так же Вы могли заметить в последнем примере, что для объединения словаря в строку метод join() использует не значения, а ключи. Если Вам нужны именно ключи, то делается это так:


var: dict[str, str] = {'1': '4', '2': '5', '3': '6'}
print('->'.join(var.values()))
# Вывод:

4->5->6

Сложнее ситуация, когда нужны пары ключ-значение. Здесь придётся сперва распаковать кортежи.


var: dict[str, str] = {'1': '4', '2': '5', '3': '6'}
print('->'.join([str(a+':'+b) for a, b in var.items()]))
# Вывод:

1:4->2:5->3:6

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

  • Часть строки до разделителя
  • Разделитель
  • Часть строки после разделителя

print('1:4->2:5->3:6'.partition(':'))
# Вывод:

('1', ':', '4->2:5->3:6')

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


print('1:4->2:5->3:6'.partition('7'))
# Вывод:

('1:4->2:5->3:6', '', '')

rpartition() делит строку на основе разделителя, начиная с конца.

rsplit() делит строку на список из подстрок. По умолчанию разделителем является пробел.


print('1:4->2:5->3:6'.rsplit('->'))
# Вывод:

['1:4', '2:5', '3:6']

split() делит строку на список из подстрок.

Ведет себя как rsplit(), за исключением того, что при указании maxsplit – максимального количества разбиений, деление начинается с левого края строки:


print('1:4->2:5->3:6'.rsplit('->', 1))
print('1:4->2:5->3:6'.split('->', 1))
# Вывод:

['1:4->2:5', '3:6']

['1:4', '2:5->3:6']

Если параметр maxsplit не указан, между rsplit() и split() разницы нет.

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

Разделитель Значение
n Новая строка
r Возврат каретки
rn Возврат каретки + перевод строки
v или же x0b Таблицы строк
f или же x0c Подача формы
x1c Разделитель файлов
x1d Разделитель групп
x1e Разделитель записей
x85 Следующая строка
u2028 Новая строка (Unicode)
u2029 Новый абзац (Unicode)

Заключение

В этом уроке мы рассмотрели основные инструменты для работы со строками в Python. Как видите, они удобны и гибки. Есть встроенные функции и методы объекта «строка», строковые литералы. Ещё больше возможностей даёт нерассмотренный в этом уроке метод format и модуль re. Так же отдельного разговора заслуживает работа с кодировками. Следует отметить для тех, кто уже знаком с другими языками программирования: в отличие от некоторых из них, один символ в Пайтоне тоже является строкой. И изюминка напоследок. Поскольку в Питоне всё является объектом, у каждой строки тоже есть атрибуты.


from pprint import pprint

pprint('Строка'.__dir__())
# Вывод:

['__repr__',

'__hash__',

'__str__',

'__getattribute__',

'__lt__',

'__le__',

'__eq__',

'__ne__',

'__gt__',

'__ge__',

'__iter__',

'__mod__',

'__rmod__',

'__len__',

'__getitem__',

'__add__',

'__mul__',

'__rmul__',

'__contains__',

'__new__',

'encode',

'replace',

'split',

'rsplit',

'join',

'capitalize',

'casefold',

'title',

'center',

'count',

'expandtabs',

'find',

'partition',

'index',

'ljust',

'lower',

'lstrip',

'rfind',

'rindex',

'rjust',

'rstrip',

'rpartition',

'splitlines',

'strip',

'swapcase',

'translate',

'upper',

'startswith',

'endswith',

'removeprefix',

'removesuffix',

'isascii',

'islower',

'isupper',

'istitle',

'isspace',

'isdecimal',

'isdigit',

'isnumeric',

'isalpha',

'isalnum',

'isidentifier',

'isprintable',

'zfill',

'format',

'format_map',

'__format__',

'maketrans',

'__sizeof__',

'__getnewargs__',

'__doc__',

'__setattr__',

'__delattr__',

'__init__',

'__reduce_ex__',

'__reduce__',

'__subclasshook__',

'__init_subclass__',

'__dir__',

'__class__']

S = ‘str’; S = «str»; S = »’str»’; S = «»»str»»» Литералы строк S = «snptanbbb» Экранированные последовательности S = r»C:tempnew» Неформатированные строки (подавляют экранирование) S = b»byte» Строка байтов S1 + S2 Конкатенация (сложение строк) S1 * 3 Повторение строки S[i] Обращение по индексу S[i:j:step] Извлечение среза len(S) Длина строки S.find(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или -1 S.rfind(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или -1 S.index(str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError S.rindex(str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError S.replace(шаблон, замена[, maxcount]) Замена шаблона на замену. maxcount ограничивает количество замен S.split(символ) Разбиение строки по разделителю S.isdigit() Состоит ли строка из цифр S.isalpha() Состоит ли строка из букв S.isalnum() Состоит ли строка из цифр или букв S.islower() Состоит ли строка из символов в нижнем регистре S.isupper() Состоит ли строка из символов в верхнем регистре S.isspace() Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы (‘f’), «новая строка» (‘n’), «перевод каретки» (‘r’), «горизонтальная табуляция» (‘t’) и «вертикальная табуляция» (‘v’)) S.istitle() Начинаются ли слова в строке с заглавной буквы S.upper() Преобразование строки к верхнему регистру S.lower() Преобразование строки к нижнему регистру S.startswith(str) Начинается ли строка S с шаблона str S.endswith(str) Заканчивается ли строка S шаблоном str S.join(список) Сборка строки из списка с разделителем S ord(символ) Символ в его код ASCII chr(число) Код ASCII в символ S.capitalize() Переводит первый символ строки в верхний регистр, а все остальные в нижний S.center(width, [fill]) Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию) S.count(str, [start],[end]) Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию) S.expandtabs([tabsize]) Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам S.lstrip([chars]) Удаление пробельных символов в начале строки S.rstrip([chars]) Удаление пробельных символов в конце строки S.strip([chars]) Удаление пробельных символов в начале и в конце строки S.partition(шаблон) Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки S.rpartition(sep) Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку S.swapcase() Переводит символы нижнего регистра в верхний, а верхнего – в нижний S.title() Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний S.zfill(width) Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями S.ljust(width, fillchar=» «) Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar S.rjust(width, fillchar=» «) Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar S.format(*args, **kwargs) Форматирование строки

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

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

Ниже рассмотрим операторы, методы и функции, доступные для работы с текстом.

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

Вы уже видели операторы + и * в применении их к числовым значениям в уроке по операторам в Python . Эти два оператора применяются и к строкам.

Оператор сложения строк +

+ — оператор конкатенации строк. Он возвращает строку, состоящую из других строк, как показано здесь:

>>> s = 'py'
>>> t = 'th'
>>> u = 'on'

>>> s + t
'pyth'
>>> s + t + u
'python'

>>> print('Привет, ' + 'Мир!')
Go team!!!

Оператор умножения строк *

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

s * n
n * s

Вот примеры умножения строк:

>>> s = 'py.'

>>> s * 4
'py.py.py.py.'
>>> 4 * s
'py.py.py.py.'

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

>>> 'py' * -6
''

Если вы создадите строковую переменную и превратите ее в пустую строку, с помощью 'py' * -6, кто-нибудь будет справедливо считать вас немного глупым. Но это сработает.

Оператор принадлежности подстроки in

Python также предоставляет оператор принадлежности, который можно использоваться для манипуляций со строками. Оператор in возвращает True, если подстрока входит в строку, и False, если нет:

>>> s = 'Python'
>>> s in 'I love Python.'
True
>>> s in 'I love Java.'
False

Есть также оператор not in, у которого обратная логика:

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

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

Функция Описание
chr() Преобразует целое число в символ
ord() Преобразует символ в целое число
len() Возвращает длину строки
str() Изменяет тип объекта на string

Более подробно о них ниже.

Функция ord(c) возвращает числовое значение для заданного символа.

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

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

>>> ord('a')
97
>>> ord('#')
35

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

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

Функция ord() также возвращает числовые значения для символов Юникода:

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

Функция chr(n) возвращает символьное значение для данного целого числа.

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

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

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

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

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

len(s) возвращает количество символов в строке s:

>>> s = 'Простоя строка.'
>>> len(s)
15

Функция str(obj) возвращает строковое представление объекта.

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

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('py')
'py'

Индексация строк

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

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

Индексация строк начинается с нуля: у первого символа индекс 0, следующего 1 и так далее. Индекс последнего символа в python — ‘‘длина строки минус один’’.

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

индексация строки в python

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

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> s[5]
'r'

Попытка обращения по индексу большему чем len(s) - 1, приводит к ошибке IndexError:

>>> s[6]
Traceback (most recent call last):
  File "", line 1, in <module>
    s[6]
IndexError: string index out of range

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

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

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

>>> s = 'foobar'
>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)] # отрицательная индексация начинается с -1
'f'

Попытка обращения по индексу меньшему чем -len(s), приводит к ошибке IndexError:

>>> s[-7]
Traceback (most recent call last):
  File "", line 1, in <module>
    s[-7]
IndexError: string index out of range

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

Срезы строк

Python также допускает возможность извлечения подстроки из строки, известную как ‘‘string slice’’. Если s это строка, выражение формы s[m:n] возвращает часть s, начинающуюся с позиции m, и до позиции n, но не включая позицию:

>>> s = 'python'
>>> s[2:5]
'tho'

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

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

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

>>> s = 'python'
>>> s[:4]
'pyth'
>>> s[0:4]
'pyth'

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

>>> s = 'python'
>>> s[2:]
'thon'
>>> s[2:len(s)]
'thon'

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

>>> s = 'python'
>>> s[:4] + s[4:]
'python'
>>> s[:4] + s[4:] == s
True

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

>>> s = 'python'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

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

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

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

>>> s = 'python'
>>> s[-5:-2]
'yth'
>>> s[1:4]
'yth'
>>> s[-5:-2] == s[1:4]
True

Шаг для среза строки

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

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

срез строки python с шагом 2

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

>>> s = 'foobar'
>>> s[0:6:2]
'foa'
>>> s[1:6:2]
'obr'

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

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

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

>>> s = 'python'
>>> s[5:0:-2]
'nhy'

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

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

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

Это общая парадигма для разворота (reverse) строки:

>>> s = 'Если так говорит товарищ Наполеон, значит, так оно и есть.'
>>> s[::-1]
'.ьтсе и оно кат ,тичанз ,ноелопаН щиравот тировог кат илсЕ'

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

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

Возможности форматирования строк огромны и не будут подробно описана здесь.
Одной простой особенностью f-строк, которые вы можете начать использовать сразу, является интерполяция переменной. Вы можете указать имя переменной непосредственно в f-строковом литерале (f'string'), и python заменит имя соответствующим значением.

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

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

Но это громоздко. Чтобы выполнить то же самое с помощью f-строки:

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

Код с использованием f-string, приведенный ниже выглядит намного чище:

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

Любой из трех типов кавычек в python можно использовать для f-строки:

>>> var = 'Гав'
>>> print(f'Собака говорит {var}!')
Собака говорит Гав!
>>> print(f"Собака говорит {var}!")
Собака говорит Гав!
>>> print(f'''Собака говорит {var}!''')
Собака говорит Гав!

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

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

Такой синтаксис приведет к ошибке TypeError:

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

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

>>> s = s[:3] + 't' + s[4:]
>>> s
'pytton'

Есть встроенный метод string.replace(x, y):

>>> s = 'python'
>>> s = s.replace('h', 't')
>>> s
'pytton'

Читайте дальше о встроенных методах строк!

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

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

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

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

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

obj.foo(<args>)

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

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

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

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

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

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

s.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.lower() возвращает копию s со всеми буквенными символами, преобразованными в нижний регистр:

>>> 'everyTHing yoU Can IMaGine is rEAl'.lower()
'everything you can imagine is real'

string.swapcase() меняет регистр буквенных символов на противоположный.

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

>>> 'everyTHing yoU Can IMaGine is rEAl'.swapcase()
'EVERYthING YOu cAN imAgINE IS ReaL'

string.title() преобразует первые буквы всех слов в заглавные

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

>>> 'the sun also rises'.title()
'The Sun Also Rises'

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

>>> 'follow us @PYTHON'.title()
'Follow Us @Python'

string.upper() преобразует все буквенные символы в заглавные.

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

>>> 'follow us @PYTHON'.upper()
'FOLLOW US @PYTHON'

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

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

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

string.count([, [, ]]) подсчитывает количество вхождений подстроки в строку.

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

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

Количество вхождений изменится, если указать и :

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

string.endswith([, [, ]]) определяет, заканчивается ли строка заданной подстрокой.

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

>>> 'python'.endswith('on')
True
>>> 'python'.endswith('or')
False

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

>>> 'python'.endswith('yt', 0, 4)
True
>>> 'python'.endswith('yt', 2, 4)
False

string.find([, [, ]]) ищет в строке заданную подстроку.

s.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 <module>
    'Follow Us @Python'.index('you')
ValueError: substring not found

string.rfind([, [, ]]) ищет в строке заданную подстроку, начиная с конца.

s.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 <module>
    'Follow Us @Python'.rindex('you')
ValueError: substring not found

string.startswith([, [, ]]) определяет, начинается ли строка с заданной подстроки.

s.startswith() возвращает, 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() определяет, состоит ли строка из букв и цифр.

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

>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

string.isalpha() определяет, состоит ли строка только из букв.

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

>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

string.isdigit() определяет, состоит ли строка из цифр (проверка на число).

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

>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

string.isidentifier() определяет, является ли строка допустимым идентификатором Python.

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

>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

Важно: .isidentifier() вернет True для строки, которая соответствует зарезервированному ключевому слову python, даже если его нельзя использовать:

>>> 'and'.isidentifier()
True

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

>>> from keyword import iskeyword
>>> iskeyword('and')
True

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

string.islower() определяет, являются ли буквенные символы строки строчными.

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

>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

string.isprintable() определяет, состоит ли строка только из печатаемых символов.

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

>>> 'atb'.isprintable() # t - символ табуляции
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'anb'.isprintable() # n - символ перевода строки
False

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

string.isspace() определяет, состоит ли строка только из пробельных символов.

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

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

>>> ' t  n '.isspace()
True
>>> ' a '.isspace()
False

Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:

>>> 'fu2005r'.isspace()
True

'f' и 'r' являются escape-последовательностями для символов ASCII; 'u2005' это escape-последовательность для Unicode.

string.istitle() определяет, начинаются ли слова строки с заглавной буквы.

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

>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

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

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

>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False

Выравнивание строк, отступы

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

string.center([, ]) выравнивает строку по центру.

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

>>> 'py'.center(10)
'    py    '

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

>>> 'py'.center(10, '-')
'----py----'

Если s больше или равна , строка возвращается без изменений:

>>> 'python'.center(2)
'python'

string.expandtabs(tabsize=8) заменяет табуляции на пробелы

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

>>> 'atbtc'.expandtabs()
'a       b       c'
>>> 'aaatbbbtc'.expandtabs()
'aaa     bbb     c'

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

>>> 'atbtc'.expandtabs(4)
'a   b   c'
>>> 'aaatbbbtc'.expandtabs(tabsize=4)
'aaa bbb c'

string.ljust([, ]) выравнивание по левому краю строки в поле.

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

>>> 'python'.ljust(10)
'python    '

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

>>> 'python'.ljust(10, '-')
'python----'

Если s больше или равна , строка возвращается без изменений:

>>> 'python'.ljust(2)
'python'

string.lstrip([]) обрезает пробельные символы слева

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

>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> 'tnfootnbartnbaz'.lstrip()
'footnbartnbaz'

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

>>> 'https://www.pythonru.com'.lstrip('/:pths')
'www.pythonru.com'

string.replace(, [, ]) заменяет вхождения подстроки в строке.

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

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love')
'I love python! I love python! I love python!'

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

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love', 2)
'I love python! I love python! I hate python!'

string.rjust([, ]) выравнивание по правому краю строки в поле.

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

>>> 'python'.rjust(10)
'    python'

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

>>> 'python'.rjust(10, '-')
'----python'

Если s больше или равна , строка возвращается без изменений:

>>> 'python'.rjust(2)
'python'

string.rstrip([]) обрезает пробельные символы справа

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

>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'footnbartnbaztn'.rstrip()
'footnbartnbaz'

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

>>> 'foo.$$$;'.rstrip(';$.')
'foo'

string.strip([]) удаляет символы с левого и правого края строки.

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

>>> s = '   foo bar bazttt'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'

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

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

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

>>> '   foo bar bazttt'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar bazttt'.strip()
'foo bar baz'

>>> 'www.pythonru.com'.lstrip('w.').rstrip('.moc')
'pythonru'
>>> 'www.pythonru.com'.strip('w.moc')
'pythonru'

string.zfill() дополняет строку нулями слева.

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

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

Если s содержит знак перед цифрами, он остается слева строки:

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

Если s больше или равна , строка возвращается без изменений:

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

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

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

Методы преобразование строки в список

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

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

Теперь давайте посмотрим на последнюю группу строковых методов.

string.join() объединяет список в строку.

s.join() возвращает строку, которая является результатом конкатенации объекта с разделителем s.

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

Примеры кода помогут вникнуть. В первом примере разделителем s является строка ', ', а список строк:

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

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

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

>>> list('corge')
['c', 'o', 'r', 'g', 'e']

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

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

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

>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "", line 1, in <module>
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found

Это можно исправить так:

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

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

string.partition() делит строку на основе разделителя.

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

  • Часть s до
  • Разделитель
  • Часть s после

Вот пара примеров .partition()в работе:

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

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

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

s.rpartition() делит строку на основе разделителя, начиная с конца.

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

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

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

string.rsplit(sep=None, maxsplit=-1) делит строку на список из подстрок.

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

>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foontbar   bazrfqux'.rsplit()
['foo', 'bar', 'baz', 'qux']

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

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

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

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

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

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

>>> 'footttbar'.rsplit()
['foo', 'bar']

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

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

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

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

string.split(sep=None, maxsplit=-1) делит строку на список из подстрок.

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

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

Если не указано, между .rsplit() и .split() в python разницы нет.

string.splitlines([]) делит текст на список строк.

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

Разделитель Значение
n Новая строка
r Возврат каретки
rn Возврат каретки + перевод строки
v или же x0b Таблицы строк
f или же x0c Подача формы
x1c Разделитель файлов
x1d Разделитель групп
x1e Разделитель записей
x85 Следующая строка
u2028 Новая строка (Unicode)
u2029 Новый абзац (Unicode)

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

>>> 'foonbarrnbazfquxu2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']

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

>>> 'foofffbar'.splitlines()
['foo', '', '', 'bar']

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

>>> 'foonbarnbaznqux'.splitlines(True)
['foon', 'barn', 'bazn', 'qux']
>>> 'foonbarnbaznqux'.splitlines(8)
['foon', 'barn', 'bazn', 'qux']

Заключение

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

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

  • Списки python
  • Кортежи (tuple)

Текстовые переменные str в Питоне

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

        >>> stroka = 'Python'
>>> type(stroka)
<class 'str'>
>>> stroka2 = "code"
>>> type(stroka2)
<class 'str'>

    

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

        stroka = ''
    

Или:

        stroka2 = ""
    

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

        >>> print("'Самоучитель Python' - возможно, лучший справочник по Питону.")
'Самоучитель Python' - возможно, лучший справочник по Питону.
>>> print('"Самоучитель Python" - возможно, лучший справочник по Питону.')
"Самоучитель Python" - возможно, лучший справочник по Питону.

    

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

        >>> print(""Самоучитель Python" - возможно, лучший справочник по Питону.")
  File "<pyshell>", line 1
    print(""Самоучитель Python" - возможно, лучший справочник по Питону.")
                      ^
SyntaxError: invalid syntax

    

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

        >>> print('''В тройные кавычки заключают многострочный текст.
Программный код также можно выделить тройными кавычками.''')
В тройные кавычки заключают многострочный текст.
Программный код также можно выделить тройными кавычками.

    

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

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

        >>> stroka = 'python'
>>> print(len(stroka))
6
>>> stroka1 = ' '
>>> print(len(stroka1))
1

    

Преобразование других типов данных в строку

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

        >>> number1 = 55
>>> number2 = 55.5
>>> stroka1 = str(number1)
>>> stroka2 = str(number2)
>>> print(type(stroka1))
<class 'str'>
>>> print(type(stroka2))
<class 'str'>

    

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

Сложение и умножение строк

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

        >>> str1 = 'Python'
>>> str2 = ' - '
>>> str3 = 'самый гибкий язык программирования'
>>> print(str1 + str2 + str3)
Python - самый гибкий язык программирования

    

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

        >>> stroka = '*** '
>>> print(stroka * 5)
*** *** *** *** ***

    

Подстроки

Подстрокой называется фрагмент определенной строки. Например, ‘abra’ является подстрокой ‘abrakadabra’. Чтобы определить, входит ли какая-то определенная подстрока в строку, используют оператор in:

        >>> stroka = 'abrakadabra'
>>> print('abra' in stroka)
True
>>> print('zebra' in stroka)
False

    

Для обращения к определенному символу строки используют индекс – порядковый номер элемента. Python поддерживает два типа индексации – положительную, при которой отсчет элементов начинается с 0 и с начала строки, и отрицательную, при которой отсчет начинается с -1 и с конца:

Положительные индексы 0 1 2 3 4 5 6
Пример строки P r o g l i b
Отрицательные индексы -7 -6 -5 -4 -3 -2 -1

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

        >>> stroka = 'программирование'
>>> print(stroka[7])
м
>>> print(stroka[-1])
е

    

Срезы строк в Python

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

        >>> stroka = 'программирование'
>>> print(stroka[7:10])
мир

    

Диапазон среза [a:b] начинается с первого указанного элемента а включительно, и заканчивается на последнем, не включая b в результат:

        >>> stroka = 'программa'
>>> print(stroka[3:8])
грамм
    

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

        >>> stroka = 'программa'
>>> print(stroka[:4])
прог

    

В случае отсутствия второго элемента [a:] срез будет сделан с позиции первого символа и до конца строки:

        >>> stroka = 'программa'
>>> print(stroka[3:])
граммa

    

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

        >>> stroka = 'позиции не заданы'
>>> print(stroka[:])
позиции не заданы

    

Шаг среза

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

        >>> stroka = 'Python лучше всего подходит для новичков.'
>>> print(stroka[1:15:3])
yoлшв

    

Шаг может быть отрицательным – в этом случае символы будут выбираться, начиная с конца строки:

        >>> stroka = 'это пример отрицательного шага'
>>> print(stroka[-1:-15:-4])
а нт

    

Срез [::-1] может оказаться очень полезным при решении задач, связанных с палиндромами:

        >>> stroka = 'А роза упала на лапу Азора'
>>> print(stroka[::-1])
арозА упал ан алапу азор А

    

Замена символа в строке

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

        >>> stroka = 'mall'
>>> stroka[0] = 'b'
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'str' object does not support item assignment

    

Но заменить любой символ все-таки можно – для этого придется воспользоваться срезами и конкатенацией. Результатом станет новая строка:

        >>> stroka = 'mall'
>>> stroka = 'b' + stroka[1:]
>>> print(stroka)
ball

    

Более простой способ «замены» символа или подстроки – использование метода replace(), который мы рассмотрим ниже.

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

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

  • Преобразование строк.
  • Оценка и классификация строк.
  • Конвертация регистра.
  • Поиск, подсчет и замена символов.

Рассмотрим эти методы подробнее.

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

Три самых используемых метода из этой группы – join(), split() и partition(). Метод join() незаменим, если нужно преобразовать список или кортеж в строку:

        >>> spisok = ['Я', 'изучаю', 'Python']
>>> stroka = ' '.join(spisok)
>>> print(stroka)
Я изучаю Python

    

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

        >>> kort = ('Я', 'изучаю', 'Django')
>>> stroka = '***'.join(kort)
>>> print(stroka)
Я***изучаю***Django

    

Метод split() используется для обратной манипуляции – преобразования строки в список:

        >>> text = 'это пример текста для преобразования в список'
>>> spisok = text.split()
>>> print(spisok)
['это', 'пример', 'текста', 'для', 'преобразования', 'в', 'список']

    

По умолчанию split() разбивает строку по пробелам. Но можно указать любой другой символ – и на практике это часто требуется:

        >>> text = 'цвет: синий; вес: 1 кг; размер: 30х30х50; материал: картон'
>>> spisok = text.split(';')
>>> print(spisok)
['цвет: синий', ' вес: 1 кг', ' размер: 30х30х50', ' материал: картон']

    

Метод partition() поможет преобразовать строку в кортеж:

        >>> text = 'Python - простой и понятный язык'
>>> kort = text.partition('и')
>>> print(kort)
('Python - простой ', 'и', ' понятный язык')

    

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

Оценка и классификация строк

В Python много встроенных методов для оценки и классификации текстовых данных. Некоторые из этих методов работают только со строками, в то время как другие универсальны. К последним относятся, например, функции min() и max():

        >>> text = '12345'
>>> print(min(text))
1
>>> print(max(text))
5


    

В Python есть специальные методы для определения типа символов. Например, isalnum() оценивает, состоит ли строка из букв и цифр, либо в ней есть какие-то другие символы:

        >>> text = 'abracadabra123456'
>>> print(text.isalnum())
True
>>> text1 = 'a*b$ra cadabra'
>>> print(text1.isalnum())
False

    

Метод isalpha() поможет определить, состоит ли строка только из букв, или включает специальные символы, пробелы и цифры:

        >>> text = 'программирование'
>>> print(text.isalpha())
True
>>> text2 = 'password123'
>>> print(text2.isalpha())
False

    

С помощью метода isdigit() можно определить, входят ли в строку только цифры, или там есть и другие символы:

        >>> text = '1234567890'
>>> print(text.isdigit())
True
>>> text2 = '123456789o'
>>> print(text2.isdigit())
False

    

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

        >>> text = '5.55'
>>> print(text.isdigit())
False
>>> text1 = '-5'
>>> print(text1.isdigit())
False
    

Если нужно определить наличие в строке дробей или римских цифр, подойдет метод isnumeric():

        >>> text = '½⅓¼⅕⅙'
>>> print(text.isdigit())
False
>>> print(text.isnumeric())
True

    

Методы islower() и isupper() определяют регистр, в котором находятся буквы. Эти методы игнорируют небуквенные символы:

        >>> text = 'abracadabra'
>>> print(text.islower())
True
>>> text2 = 'Python bytes'
>>> print(text2.islower())
False
>>> text3 = 'PYTHON'
>>> print(text3.isupper())
True

    

Метод isspace() определяет, состоит ли анализируемая строка из одних пробелов, или содержит что-нибудь еще:

        >>> stroka = '   '
>>> print(stroka.isspace())
True
>>> stroka2 = '  a  '
>>> print(stroka2.isspace())
False

    

Конвертация регистра

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

Из всех методов, связанных с конвертацией регистра, наиболее часто используются на практике два – lower() и upper(). Они преобразуют все символы в нижний и верхний регистр соответственно:

        >>> text = 'этот текст надо написать заглавными буквами'
>>> print(text.upper())
ЭТОТ ТЕКСТ НАДО НАПИСАТЬ ЗАГЛАВНЫМИ БУКВАМИ
>>> text = 'зДесь ВСе букВы рАзныЕ, а НУжнЫ проПИСНыЕ'
>>> print(text.lower())
здесь все буквы разные, а нужны прописные

    

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

        >>> text = 'предложение должно начинаться с ЗАГЛАВНОЙ буквы.'
>>> print(text.capitalize())
Предложение должно начинаться с заглавной буквы.

    

Методы swapcase() и title() используются реже. Первый заменяет исходный регистр на противоположный, а второй – начинает каждое слово с заглавной буквы:

        >>> text = 'пРИМЕР иСПОЛЬЗОВАНИЯ swapcase'
>>> print(text.swapcase())
Пример Использования SWAPCASE
>>> text2 = 'тот случай, когда нужен метод title'
>>> print(text2.title())
Тот Случай, Когда Нужен Метод Title

    

Поиск, подсчет и замена символов

Методы find() и rfind() возвращают индекс стартовой позиции искомой подстроки. Оба метода учитывают только первое вхождение подстроки. Разница между ними заключается в том, что find() ищет первое вхождение подстроки с начала текста, а rfind() с конца:

        >>> text = 'пример текста, в котором нужно найти текстовую подстроку'
>>> print(text.find('текст'))
7
>>> print(text.rfind('текст'))
37

    

Такие же результаты можно получить при использовании методов index() и rindex() – правда, придется предусмотреть обработку ошибок, если искомая подстрока не будет обнаружена:

        >>> text = 'Съешь еще этих мягких французских булок!'
>>> print(text.index('еще'))
6
>>> print(text.rindex('чаю'))
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
ValueError: substring not found

    

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

        >>> text = 'Жила-была курочка Ряба'
>>> print(text.startswith('Жила'))
True

    

Чтобы проверить, заканчивается ли строка на нужное окончание, используют endswith():

        >>> text = 'В конце всех ждал хэппи-енд'
>>> print(text.endswith('енд'))
True

    

Для подсчета числа вхождений определенного символа или подстроки применяют метод count() – он помогает подсчитать как общее число вхождений в тексте, так и вхождения в указанном диапазоне:

        >>> text = 'Съешь еще этих мягких французских булок, да выпей же чаю!'
>>> print(text.count('е'))
5
>>> print(text.count('е', 5, 25))
2

    

Методы strip(), lstrip() и rstrip() предназначены для удаления пробелов. Метод strip() удаляет пробелы в начале и конце строки, lstrip() – только слева, rstrip() – только справа:

        >>> text = '    здесь есть пробелы и слева, и справа    '
>>> print('***', text.strip(), '***')
*** здесь есть пробелы и слева, и справа ***
>>> print('***', text.lstrip(), '***')
*** здесь есть пробелы и слева, и справа     ***
>>> print('***', text.rstrip(), '***')
***     здесь есть пробелы и слева, и справа ***
    

Метод replace() используют для замены символов или подстрок. Можно указать нужное количество замен, а сам символ можно заменить на пустую подстроку – проще говоря, удалить:

        >>> text = 'В этой строчке нужно заменить только одну "ч"'
>>> print(text.replace('ч', '', 1))
В этой строке нужно заменить только одну "ч"

    

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

Практика

Задание 1

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

  • количество символов, содержащихся в тексте;
  • True или False в зависимости от того, являются ли все символы буквами и цифрами.

Решение:

        text = input()
print(len(text))
print(text.isalpha())

    

Задание 2

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

Решение:

        text = input().lower()
print(text == text[::-1])

    

Задание 3

Напишите программу, которая получает строку с именем, отчеством и фамилией, написанными в произвольном регистре, и выводит данные в правильном формате. Например, строка алеКСандр СЕРГЕЕВИЧ ПушкиН должна быть преобразована в Александр Сергеевич Пушкин.

Решение:

        text = input()
print(text.title())

    

Задание 4

Имеется строка 12361573928167047230472012. Напишите программу, которая преобразует строку в текст один236один573928один670472304720один2.

Решение:

        text = '12361573928167047230472012'
print(text.replace('1', 'один'))

    

Задание 5

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

Пример ввода:

        Алексей
Константинович
Романов
бухгалтер

    

Вывод:

        А. К. Романов, бухгалтер
    

Решение:

        first_name, patronymic, last_name, position = input(), input(), input(), input()
print(first_name[0] + '.', patronymic[0] + '.', last_name + ',', position)

    

Задание 6

Напишите программу, которая получает на вход строку текста и букву, а затем определяет, встречается ли данная буква (в любом регистре) в тексте. В качестве ответа программа должна выводить True или False.

Пример ввода:

        ЗонтИК
к

    

Вывод:

        True
    

Решение:

        text = input().lower()
letter = input()
print(letter in text)

    

Задание 7

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

Решение:

        vowels = 'аиеёоуыэюя'
letter = input().lower()
print(letter in vowels)

    

Задание 8

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

Пример ввода:

        Шесть шустрых мышат в камышах шуршат
ша

    

Вывод:

        16 33
    

Решение:

        text, letter = input().lower(), input()
print(text.find(letter), text.rfind(letter))

    

Задание 9

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

Пример ввода:

        В роще, травы шевеля, мы нащиплем щавеля
    

Вывод:

        Количество пробелов: 6, количество других символов: 34
    

Решение:

        text = input()
nospace = text.replace(' ', '')
print(f"Количество пробелов: {text.count(' ')}, количество других символов: {len(nospace)}")

    

Задание 10

Напишите программу, которая принимает строку и две подстроки start и end, а затем определяет, начинается ли строка с фрагмента start, и заканчивается ли подстрокой end. Регистр не учитывать.

Пример ввода:

        Программирование на Python - лучшее хобби
про
про

    

Вывод:

        True
False

    

Решение:

        text, start, end = input().lower(), input(), input()
print(text.startswith(start))
print(text.endswith(end))

    

Подведем итоги

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

***

📖 Содержание самоучителя

  1. Особенности, сферы применения, установка, онлайн IDE
  2. Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
  3. Типы данных: преобразование и базовые операции
  4. Методы работы со строками
  5. Методы работы со списками и списковыми включениями
  6. Методы работы со словарями и генераторами словарей
  7. Методы работы с кортежами
  8. Методы работы со множествами
  9. Особенности цикла for
  10. Условный цикл while
  11. Функции с позиционными и именованными аргументами
  12. Анонимные функции
  13. Рекурсивные функции
  14. Функции высшего порядка, замыкания и декораторы
  15. Методы работы с файлами и файловой системой

***

Материалы по теме

  • ТОП-15 трюков в Python 3, делающих код понятнее и быстрее

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

Начнем с теории. Строка – это последовательность символов произвольной длины. Также строки являются объектами класса str, и если мы захотим получить не строку, а число, то можем использовать функцию приведения.

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

Самый простой способ склеить строки в Python – это сложить их с помощью знака «+». Рассмотрим на примере:

str = "a"+"b"
print(str) # Выведет "ab"

Но такой способ не всегда будет нам подходить. Рассмотрим метод join():

str = ["a", "b", "c"]
print("".join(str)) # Выведет "abc"

Перед .join() мы указываем разделитель строк, а в скобках сам их массив.

Для того чтобы разделить строки, используем обратный метод – split(). Тут в скобках указываем набор символов, по которым будет идти разделение, а перед методом не забываем указать имя строки, а после нее поставить точку. Рассмотрим на примере:

str = "a,b,c"
print(str.split(",")) # Выведет ['a', 'b', 'c']

Существует и другой способ разделения строк, он называется срез. Срез str[x:y] позволит нам получить строку от символа x до y. При этом необязательно указывать оба параметра, ведь в таком случае срез произойдет от начала или до самого конца строки. 

Определенный промежуток:

str = "Строки в Python и методы работы с ними"
print(str[9:15]) # Выведет "Python"

С начала строки:

str = "Строки в Python и методы работы с ними"
print(str[:15]) # Выведет "Строки в Python"

До самого конца:

str = "Строки в Python и методы работы с ними"
print(str[18:]) # Выведет "методы работы с ними"

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

str = "123456789"
print(str[::2]) # Выведет "13579"

Комьюнити теперь в Телеграм

Подпишитесь и будьте в курсе последних IT-новостей

Подписаться

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

Для подстановки в строку любой переменной, которая может являться результатом работы основной части кода, нам понадобятся f-строки. Они появились в Python 3.6, поэтому я рекомендую использовать только свежие версии этого языка программирования. Рассмотрим на примере работу с f-строками:

num = 2*10
num2 = 100
str = f"Первое число: {num}. Второе число: {num2}"
print(str) # Выведет "Первое число: 20. Второе число: 100"

Поиск в строках

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

Первый метод – startswith(). Он позволяет искать набор символов в начале строки. Рассмотрим на примере:

str =  "Строки в Python и методы работы с ними"
print(str.startswith("Строки")) #Выведет True

Второй метод – endswith(). Он позволяет искать набор символов в конце строки. Рассмотрим на примере:

str =  "...я разбирал строки в JavaScript"
print(str.endswith("JavaScript")) #Выведет True

А если нам нужно найти набор символов в произвольном месте строки, то используем метод find(). Рассмотрим на примере:

str = "Строки в Python и методы работы с ними"
print(str.find("Python")) #Выведет 9

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

str = "Строки в Python и методы работы с ними"
print(str.find("JavaScript")) #Выведет -1

А в этом случае скрипт не нашел набор символов в строке и вывел «-1».

Замена в строках

Для замены одного набора символов на другой в строке используют метод replace(). Рассмотрим данный метод на примере:

str = "Строки в Python и методы работы с ними"
print(str.replace("Python", "JavaScript")) #Выведет "JavaScript"

Вывод каждого символа в строке

Если нам нужно получить и обработать каждый символ в строке отдельно, то мы можем использовать цикл for. Рассмотрим на примере:

str = "123"
for i in str:
print(i) #Выведет "1" "2" "3"

Узнаем длину строки

Для того чтобы получить длину строки, используем метод len():

str = "123"
print(len(str)) # Выведет 3

Преобразование строки в число

Если мы имеем строку, состоящую из набора цифр, то мы смело можем преобразовать ее в число, используя функцию приведения int(). Рассмотрим на примере:

str = "123"
print(int(str)) # Выведет 123

Изменение регистра строк в Python

Для того чтобы все буквы в строке были заглавными, используем метод upper():

str = "Строки в Python и методы работы с ними"
print(str.upper()) # Выведет "СТРОКИ В PYTHON И МЕТОДЫ РАБОТЫ С НИМИ"

И метод lower() для строчных букв:

str = "СТРОКИ В PYTHON И МЕТОДЫ РАБОТЫ С НИМИ"
print(str.upper()) # Выведет "строки в python и методы работы с ними"

Чтобы первая буква в строке стала заглавной, следует использовать метод capitalize():

str = "строки в python и методы работы с ними"
print(str.capitalize()) # Выведет "Строки в python и методы работы с ними"

Удаление лишних пробелов из строк

Метод strip() удаляет пробельные символы в начале и в конце строки. lstrip() и rstrip() делают то же самое, но в определенных местах: первый метод в начале строки, а второй – в ее конце.

Итог

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

Функции обрабатывающие регистр символов в строке


Содержание

  • 1. Функция str.capitalize(). Первый символ строки становится прописным
  • 2. Функция str.casefold(). Вернуть свернутую копию строки
  • 3. Функция str.lower(). Преобразование регистра символов
  • 4. Функция str.swapcase(). Вернуть копию строки с преобразованием строчных символов в заглавные и наоборот
  • 5. Функция str.title(). Вернуть строку с заглавными буквами в словах
  • 6. Функция str.upper(). Конвертировать символы строки в верхний регистр
  • Связанные темы

Поиск на других ресурсах:

1. Функция str.capitalize(). Первый символ строки становится прописным

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

Пример.

# Функция str.capitalize()
# Ко вниманию принимаются только буквы
s1 = 'abcdef ghi'
s2 = str.capitalize(s1) # s2 = 'Abcdef ghi'

s1 = 't'
s2 = str.capitalize(s1) # s2 = 'T'

s1 = '234'
s2 = str.capitalize(s1) # s2 = '234'

s1 = 'ABCDEF GHI'
s2 = str.capitalize(s1) # s2 = 'Abcdef ghi'

# Учет кирилличной азбуки
s1 = 'байт!'
s2 = str.capitalize(s1) # s2 = 'xc1xe0xe9xf2!'

 

2. Функция str.casefold(). Вернуть свернутую копию строки

Функция str.casefold() возвращает свернутую копию строки. Понятие «свернутая копия» строки означает, что в такой копии удалены все отличия регистра символов в строке.
Особенность «свернутой» копии строки состоит в том, что функция lower() не может быть применена к некоторым символам, а функция casefold() может. Примером такого символа есть немецкий символ ‘ß’, который в функции casefold() заменяется на символы ss в отличие от функции lower().

Функция введена в Python начиная из версии 3.3.

Пример.

# Функция casefold() - возвращает свернутую копию строки

# Использование со строками, содержащими символы верхнего и нижнего регистров
s1 = 'Abcdef Ghi'
s2 = str.casefold(s1) # s2 = 'abcdef ghi'
s3 = s1.casefold() # s3 = 'abcdef ghi'

# использование со строками, содержащими символы верхнего регистра
s4 = 'ABCDEF SS'
s5 = s4.casefold() # s5 = 'abcdef ss'

 

3. Функция str.lower(). Преобразование регистра символов

Функция str.lower() преобразовывает символы в нижний регистр.

Пример.

# Функция str.lower()

s1 = 'ABCD'
s2 = s1.lower() # s2 = 'abcd'

s2 = 'Hello World!'.lower() # s2 = 'hello world!'


 

4. Функция str.swapcase(). Вернуть копию строки с преобразованием строчных символов в заглавные и наоборот

Функция str.swapcase() возвращает копию строки с заглавными буквами, преобразованными в строчные и, наоборот, строчными преобразованными в заглавные. Общая форма вызова функции следующая:

s2 = s1.swapcase()

где

  • s1 – исходная строка, которую нужно преобразовать;
  • s2 – результирующая строка в которой все заглавные символы преобразованы в строчные, а все строчные преобразованы в заглавные.

Для данной функции нельзя утверждать, что нижеследующее выражение

s.swapcase().swapcase() == s

будет всегда выполняться.

Пример.

# Функция str.swapcase()

s1 = 'Abcd'
s2 = s1.swapcase() # s2 = 'aBCD'

s1 = 'a+5+BC+D'
s2 = str.swapcase(s1) # s2 = 'A+5+bc+d'

s2 = 'hELLO WORLD'.swapcase() # s2 = 'Hello world'

# Для кириллицы
s1 = 'вЕБ-САЙТ'
s2 = s1.swapcase() # s2 = 'Веб-сайт'

 

5. Функция str.title(). Вернуть строку с заглавными буквами в словах

Функция str.title() возвращает строку, в которой все слова начинаются с заглавной буквы. Другие символы в этих словах есть строчные. Общая форма использования функции следующая:

s2 = s1.title()

где

  • s1 – исходная строка;
  • s2 – результирующая строка, в которой реализуется корректировка символов, которые есть началами слов.

Функция имеет одну особенность. Символ ‘» апострофа образовывает границу слова. В некоторых случаях это нежелательно. Во избежание этого недостатка нужно использовать регулярные выражения.

Пример.

# Функция str.title

s1 = 'hello world!' # s2 = 'Hello World!'
s2 = s1.title()

s1 = 'HELLO WORLD!'
s2 = str.title(s1) # s2 = 'Hello World!'

# Отдельный случай с символом апострофа '''
s1 = "I'm happy!"
s2 = s1.swapcase() # s2 = 'i'M HAPPY!'

 

6. Функция str.upper(). Конвертировать символы строки в верхний регистр

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

s2 = s1.upper()

где

  • s1 – исходная строка;
  • s2 – результирующая строка-копия, в которой символы нижнего регистра строки s1 заменены на символы верхнего регистра.

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

  • «Lu» – Letter uppercase;
  • «Ll» – Letter lowercase;
  • «Lt» – Letter titlecase.

Пример.

# Функция str.upper()

s1 = 'abcdef'
s2 = s1.upper() # s2 = 'ABCDEF'

s1 = '' # пустая строка
s2 = str.upper(s1) # s2 = ''

s1 = '5+6=11'
s2 = s1.upper() # s2 = '5+6=11'

s2 = 'aBc deFg'.upper() # s2 = 'ABC DEFG'

 


Связанные темы

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

 


Программирование: теория и практика

Понравилась статья? Поделить с друзьями:
  • Как изменить регистр на маке
  • Как изменить регистр на клавиатуре ноутбука
  • Как изменить регистр всего текста
  • Как изменить регистр букв на клавиатуре
  • Как изменить регистр букв python