Питон работа со строками: 41 вопрос о работе со строками в Python / Блог компании RUVDS.com / Хабр

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

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

1. Как проверить два объекта на идентичность?

Не стоит путать

animals           = ['python','gopher']
more_animals      = animals
print(animals == more_animals) #=> True
print(animals is more_animals) #=> True
even_more_animals = ['python','gopher']
print(animals == even_more_animals) #=> True
print(animals is even_more_animals) #=> False

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

name = 'object'
id(name)
#=> 4408718312

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

print( 'The Hilton'.istitle() ) #=> True
print( 'The dog'.istitle() ) #=> False
print( 'sticky rice'.istitle() ) #=> False

3. Как проверить строку на вхождение в неё другой строки?

print( 'plane' in 'The worlds fastest plane' ) #=> True
print( 'car' in 'The worlds fastest plane' ) #=> False

4. Как найти индекс первого вхождения подстроки в строку?

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

'The worlds fastest plane'.find('plane') #=> 19
'The worlds fastest plane'.find('car') #=> -1

'The worlds fastest plane'.index('plane') #=> 19
'The worlds fastest plane'.index('car') #=> ValueError: substring not found

5. Как подсчитать количество символов в строке?

len('The first president of the organization..') #=> 41

6. Как подсчитать то, сколько раз определённый символ встречается в строке?

'The first president of the organization..'.count('o') #=> 3

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

'florida dolphins'.capitalize() #=> 'Florida dolphins'

8. Что такое f-строки и как ими пользоваться?

При объявлении f-строк перед открывающей кавычкой пишется буква f.

name = 'Chris'
food = 'creme brulee'
f'Hello. My name is {name} and I like {food}.'
#=> 'Hello. My name is Chris and I like creme brulee'

9. Как найти подстроку в заданной части строки?

'the happiest person in the whole wide world.'.index('the',10,44)
#=> 23

'the happiest person in the whole wide world.'.index('the')
#=> 0

10. Как вставить содержимое переменной в строку, воспользовавшись методом format()?

difficulty = 'easy'
thing = 'exam'
'That {} was {}!'.format(thing, difficulty)
#=> 'That exam was easy!'

11. Как узнать о том, что в строке содержатся только цифры?

 '80000'.isnumeric() #=> True

'1.0'.isnumeric() #=> False

12. Как разделить строку по заданному символу?

'This is great'.split(' ')
#=> ['This', 'is', 'great']
'not--so--great'.split('--')
#=> ['not', 'so', 'great']

13. Как проверить строку на то, что она составлена только из строчных букв?

'all lower case'.islower() #=> True
'not aLL lowercase'.islower() # False
 

14. Как проверить то, что строка начинается со строчной буквы?

'aPPLE'[0].islower() #=> True

15. Можно ли в Python прибавить целое число к строке?

'Ten' + 10 #=> TypeError

16. Как «перевернуть» строку?

''.join(reversed("hello world"))
#=> 'dlrow olleh'

17. Как объединить список строк в одну строку, элементы которой разделены дефисами?

'-'.join(['a','b','c'])
#=> 'a-b-c'

18. Как узнать о том, что все символы строки входят в ASCII?

print( 'Â'.isascii() ) #=> False
print( 'A'.isascii() ) #=> True

19. Как привести всю строку к верхнему или нижнему регистру?

sentence = 'The Cat in the Hat'
sentence.upper() #=> 'THE CAT IN THE HAT'
sentence.lower() #=> 'the cat in the hat'
 

20. Как преобразовать первый и последний символы строки к верхнему регистру?

animal = 'fish'
animal[0].upper() + animal[1:-1] + animal[-1].upper()
#=> 'FisH'

21. Как проверить строку на то, что она составлена только из прописных букв?

'Toronto'.isupper() #=> False
'TORONTO'.isupper() #= True

22. В какой ситуации вы воспользовались бы методом splitlines()?

sentence = "It was a stormy night\nThe house creeked\nThe wind blew."
sentence.splitlines()
#=> ['It was a stormy night', 'The house creeked', 'The wind blew.']

23. Как получить срез строки?

string[start_index:end_index:step]

string = 'I like to eat apples'
string[:6] #=> 'I like'
string[7:13] #=> 'to eat'
string[0:-1:2] #=> 'Ilk oetape' (каждый 2-й символ)
 

24. Как преобразовать целое число в строку?

str(5) #=> '5'

25. Как узнать о том, что строка содержит только алфавитные символы?

'One1'.isalpha() #=> False
'One'.isalpha() #=> True

26. Как в заданной строке заменить на что-либо все вхождения некоей подстроки?

sentence = 'Sally sells sea shells by the sea shore'
sentence.replace('sea', 'mountain')
#=> 'Sally sells mountain shells by the mountain shore'
 

27. Как вернуть символ строки с минимальным ASCII-кодом?

min('strings') #=> 'g'

28. Как проверить строку на то, что в ней содержатся только алфавитно-цифровые символы?

'Ten10'.isalnum() #=> True
'Ten10.'.isalnum() #=> False

29. Как удалить пробелы из начала строки (из её левой части), из её конца (из правой части), или с обеих сторон строки?

string = '  string of whitespace    '
string.lstrip() #=> 'string of whitespace    '
string.rstrip() #=> '  string of whitespace'
string.strip() #=> 'string of whitespace'

30. Как проверить то, что строка начинается с заданной последовательности символов, или заканчивается заданной последовательностью символов?

city = 'New York'
city.startswith('New') #=> True
city.endswith('N') #=> False

31. Как закодировать строку в ASCII?

'Fresh Tuna'.encode('ascii')
#=> b'Fresh Tuna'
'Fresh Tuna Â'.encode('ascii')
#=> UnicodeEncodeError: 'ascii' codec can't encode character '\xc2' in position 11: ordinal not in range(128)

32. Как узнать о том, что строка включает в себя только пробелы?

''.isspace() #=> False
' '.isspace() #=> True
'   '.isspace() #=> True
' the '.isspace() #=> False

33. Что случится, если умножить некую строку на 3?

'dog' * 3
# 'dogdogdog'

34. Как привести к верхнему регистру первый символ каждого слова в строке?

'once upon a time'.title() #=> 'Once Upon A Time'

35. Как объединить две строки?

'string one' + ' ' + 'string two' 
#=> 'string one string two'

36. Как пользоваться методом partition()?

sentence = "If you want to be a ninja"
print(sentence.partition(' want '))
#=> ('If you', ' want ', 'to be a ninja')

37. Строки в Python иммутабельны. Что это значит?

proverb = 'Rise each day before the sun'
print( id(proverb) )
#=> 4441962336
proverb_two = 'Rise each day before the sun' + ' if its a weekday'
print( id(proverb_two) )
#=> 4442287440

38. Если объявить одну и ту же строку дважды (записав её в 2 разные переменные) — сколько объектов будет создано в памяти? 1 или 2?

animal = 'dog'
pet = 'dog'

Доказать это можно, прибегнув к функции id().

animal = 'dog'
print( id(animal) )
#=> 4441985688
pet = 'dog'
print( id(pet) )
#=> 4441985688

39. Как пользоваться методами maketrans() и translate()?

Метод translate() позволяет применить заданную таблицу для преобразования строки.

# создаём отображение
mapping = str.maketrans("abcs", "123S")
# преобразуем строку
"abc are the first three letters".translate(mapping)
#=> '123 1re the firSt three letterS'

40. Как убрать из строки гласные буквы?

string = 'Hello 1 World 2'
vowels = ('a','e','i','o','u')
''.join([c for c in string if c not in vowels])
#=> 'Hll 1 Wrld 2'

41. В каких ситуациях пользуются методом rfind()?

story = 'The price is right said Bob. The price is right.'
story.rfind('is')
#=> 39

Итоги

Уважаемые читатели! Что, касающееся обработки строк в Python, вы посоветовали бы изучить тем, кто готовится к собеседованию?

Обработка строк в Python

В Python существуют несколько видов данных. Основные типы данных, с которыми вы столкнетесь – это string, ingteger, float, list, dict и tuple. В данной статье мы рассмотрим тип данных string (строка). Вы удивитесь тому, сколько всего можно делать со строками в Python. Также существует модуль string, который можно импортировать для получения доступа к еще большим возможностям, но мы рассмотрим его в другой статье. Вместо этого, мы пройдемся по следующим разделам:

• Как создавать строки
• Конкатенация строк
• Методы строк
• Замена строк

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

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

my_string = «Добро пожаловать в Python!» another_string = ‘Я новый текст тут…’ a_long_string = »’А это у нас новая строка в троичных скобках»’

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

my_string = «I’m a Python programmer!» otherString = ‘Слово «Python» обычно подразумевает змею’ tripleString = «»»В такой «строке» мы можем ‘использовать’ все.»»»

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

my_number = 123 my_string = str(my_number)

Если вы впишете данный код в ваш интерпретатор, вы увидите, что вы изменили значение интегратора на строку и присвоили ее переменной my_string. Это называется кастинг, или конвертирование. Вы можете конвертировать некоторые типы данных в другие, например числа в строки. Но вы также заметите, что вы не всегда можете делать обратное, например, конвертировать строку вроде ‘ABC’ в целое число. Если вы сделаете это, то получите ошибку вроде той, что указана в этом примере:

int(‘ABC’) Traceback (most recent call last): File «<string>», line 1, in <fragment> ValueError: invalid literal for int() with base 10: ‘ABC’

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

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

my_string = «abc» my_string[0] = «d» Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: ‘str’ object does not support item assignment

Здесь мы пытаемся изменить первую букву с «а» на «d«, в итоге это привело к ошибке TypeError, которая не дает нам сделать это. Теперь вы можете подумать, что присвоение новой строке то же значение и есть изменение строки. Давайте взглянем, правда ли это:

my_string = «abc» a = id(my_string) print(a) # 19397208 my_string = «def» b = id(my_string) print(b) # 25558288 my_string = my_string + «ghi» c = id(my_string) print(c) # 31345312

Проверив id объекта, мы можем определить, что когда мы присваиваем новое значение переменной, то это меняет тождество. Обратите внимание, что в версии Python, начиная с 2.0, строки могут содержать только символы ASCII. Если вам нужен Unicode, тогда вы должны вписывать u перед вашей строкой. Пример:

# -*- coding: utf-8 -*- my_unicode_string = u»Это юникод!»

В Python, начиная с версии 3, все строки являются юникодом.

> Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

> Чат и Паблик Программистов

Присоединяйтесь к нашему чату в Телеграм и подпишитесь на наш паблик в ВК.

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

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

# -*- coding: utf-8 -*- string_one = «Собака съела « string_two = «мою книгу!» string_three = string_one + string_two print(string_three) # Собака съела мою книгу!

Оператор + конкатенирует две строки в одну

Методы строк

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

my_string = «This is a string!»

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

Если вы открыли ваш интерпретатор, вы также можете сделать то же самое:

«This is a string!».upper()

Существует великое множество других методов строк. Например, если вам нужно, что бы все было в нижнем регистре, вам нужно использовать метод lower(). Если вы хотите удалить все начальные и конечные пробелы, вам понадобится метод strip(). Для получения списка всех методов строк, впишите следующую команду в ваш интерпретатор:

Вы увидите что-то на подобие этого:

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__- setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’, ‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’, ‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’, ‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’, ‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’, ‘title’, ‘translate’, ‘upper’, ‘zfill’]

Вы можете спокойно игнорировать методы, которые начинаются и заканчиваются двойным подчеркиванием, например __add__. Они не используются в ежедневном программировании в Python. Лучше обратите внимание на другие. Если вы хотите узнать, что делает тот или иной метод, просто обратитесь к справке. Например, если вы хотите узнать, зачем вам capitalize, впишите следующее, чтобы узнать:

help(my_string.capitalize)

Вы получите следующую информацию:

Help on built-in function capitalize: capitalize(…) S.capitalize() -> string Выдача копии строки S только с заглавной буквой.

Вы только что узнали кое-что о разделе, под названием интроспекция. Python может исследовать все свои объекты, что делает его очень легким в использовании. В основном, интроспекция позволяет вам спрашивать Python о нём. Вам моет быть интересно, как сказать о том, какой тип переменной был использован (другими словами int или string). Вы можете спросить об этом у Python!

type(my_string) # <type ‘str’>

Как вы видите, тип переменной my_string является str!

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

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

my_string = «I like Python!»

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

print( my_string[0:1] ) # I

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

0 1 2 3 4 5 6 7 8 9 10 11 12 13 — I l i k e P y t h o n !

Таким образом, у нас есть строка длиной в 14 символов, начиная с нуля и до тринадцати. Давайте приведем несколько примеров, чтобы понять это лучше.

my_string[:1] # ‘I’ my_string[0:12] # ‘I like Pytho’ my_string[0:13] # ‘I like Python’ my_string[0:14] # ‘I like Python!’ my_string[0:-5] # ‘I like Py’ my_string[:] # ‘I like Python!’ my_string[2:] # ‘like Python!’

Как видно в данных примерах, мы можем назначить срез, лишь указав его начало (другими словами, my_string[2:]), конец среза (my_string[:1]), или оба (my_string[0:13]). Мы можем даже использовать отрицательные значения, которые начинаются с конца строки. Так что в примере, где мы указали my_string[0:-5], начало ведется с нуля и заканчивается 5 символами, перед концом строки. Вы можете задаться вопросом «Зачем мне это и где это можно применить?». Лично я использовал это для разбора записей с фиксированной шириной в файлах, или ситуативно для парсинга сложных названий файлов, с очень специфическими наименованиями. Также я использовал это для парсинга значений в бинарных файлах. Любая работа, которая включает в себя обработку текстовых файлов, может быть намного проще, если вы понимаете, как работает нарезка и как эффективно использовать данный инструмент. Вы также можете получить доступ к отдельным символам в строке с помощью индексации. Например:

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

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

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

# -*- 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 попытается вставить ее в строку. Вы можете вставить несколько строк, добавив несколько знаков процента в свою строку. Это видно в последнем примере. Обратите внимание на то, что когда вы добавляете больше одной строки, вам нужно закрыть эти строки в круглые скобки. Теперь взглянем на то, что случится, если мы вставим недостаточное количество строк:

another_string = «Я люблю %s и %s» % «Python» Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: not enough arguments for format string

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

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 округлит числа для вас, если вы передадите ему дробь, что лучше, чем два десятичных значения. Давайте взглянем на то, что произойдет, если мы передадим неправильные данные:

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

В данном примере мы передали две строки вместо целого числа и дроби. Это привело к ошибке TypeError, что говорит нам о том, что 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

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

Шаблоны и новая методика форматирования строк

Этот метод был добавлен в Python 2.4 в виде шаблонов строк, но в качестве обычного метода string, работающего через метод format в версии 2.6. Так что это не самый свежий метод, просто обновленный. В любом случае, приступим к работе с шаблонами!

print(«%(lang)s is fun!» % {«lang»:»Python»}) # Python is fun!

Должно быть это выглядит странно, но на самом деле мы сменили наши % на %(lang), с тем отличием, что данный объект идет в комплекте с переменной. Вторая часть пример вызывает словарь Python, который мы рассмотрим в следующей статье. В основном, это пара key:value, так что когда Python ищет ключ lang в строке и в указанном словаре ключей, он заменяет этот ключ его значением. Давайте взглянем на следующие примеры:

a = «%(value)s %(value)s %(value)s !» % {«value»:»SPAM»} print(a) # SPAM SPAM SPAM ! b = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2} print(b) Traceback (most recent call last): File «<string>», line 1, in <fragment> KeyError: ‘z’ c = «%(x)i + %(y)i = %(z)i» % {«x»:1, «y»:2, «z»:3} print(c) # 1 + 2 = 3

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

a = «Python is as simple as {0}, {1}, {2}».format(«a», «b», «c») print(a) # ‘Python is as simple as a, b, c’ b = «Python is as simple as {1}, {0}, {2}».format(«a», «b», «c») print(b) # ‘Python is as simple as b, a, c’ xy = {«x»:0, «y»:10} c = «Graph a point at where x={x} and y={y}».format(**xy) print(c) # Graph a point at where x=0 and y=10

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

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

Мы проработали большой объем в данной статье. Давайте разберемся:
Сначала мы узнали, как создавать строки, после чего мы перешли к вопросу об их конкатенации. После этого, мы взглянули на несколько методов, которые предлагает нам объект string. Далее, мы рассмотрели нарезку строк и закончили замещением строк.

Работа со строками в Python: литералы

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

Это первая часть о работе со строками, а именно о литералах строк.

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

Работа со строками в Python очень удобна. Существует несколько литералов строк, которые мы сейчас и рассмотрим.

Строки в апострофах и в кавычках

S = 'spam"s'
S = "spam's"

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

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

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

«Сырые» строки — подавляют экранирование

Если перед открывающей кавычкой стоит символ ‘r’ (в любом регистре), то механизм экранирования отключается.

S = r'C:\newt.txt'

Но, несмотря на назначение, «сырая» строка не может заканчиваться символом обратного слэша. Пути решения:

S = r'\n\n\\'[:-1]
S = r'\n\n' + '\\'
S = '\\n\\n'

Строки в тройных апострофах или кавычках

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

>>> c = '''это очень большая
... строка, многострочный
... блок текста'''
>>> c
'это очень большая\nстрока, многострочный\nблок текста'
>>> print(c)
это очень большая
строка, многострочный
блок текста

Это все о литералах строк и работе с ними. О функциях и методах строк я расскажу в следующей статье.

Для вставки кода на Python в комментарий заключайте его в теги <pre><code>Ваш код</code></pre>

Методы строк в Python

a = "bee sting" 
print(a.capitalize())

a = "BEE"
print(a.casefold())

a = "bee" 
b = a.center(12, "-")
print(b)

a = "Mushroooom soup" 
print(a.count("O"))
print(a.count("o"))
print(a.count("oo"))
print(a.count("ooo"))
print(a.count("Homer"))
print(a.count("o", 4, 7))
print(a.count("o", 7))

from base64 import b64encode

a = "Banana"
print(a)

a = b64encode(a.encode())
print(a)

a = "Banana"
print(a.endswith("a"))
print(a.endswith("nana"))
print(a.endswith("z"))
print(a.endswith("an", 1, 3))

a = "1\t2\t3"
print(a)
print(a.expandtabs())
print(a.expandtabs(tabsize=12))
print(a.expandtabs(tabsize=2))

1 2   3
1       2       3
1           2           3
1    2    3

a = "Fitness"
print(a.find("F"))
print(a.find("f"))
print(a.find("n"))
print(a.find("ness"))
print(a.find("ess"))
print(a.find("z"))
print(a.find("Homer"))

# Пример 1
print("{} and {}".format("Tea", "Coffee"))

# Пример 2
print("{1} and {0}".format("Tea", "Coffee"))

# Пример 3
print("{lunch} and {dinner}".format(lunch="Peas", dinner="Beans"))

# Пример 4
print("{0}, {1}, {2}".format(*"123"))

# Пример 5
lunch = {"food": "Pizza", "drink": "Wine"}
print("Lunch: {food}, {drink}".format(**lunch))

# Пример 1
lunch = {"Food": "Pizza", "Drink": "Wine"}
print("Lunch: {Food}, {Drink}".format_map(lunch))

# Пример 2
class Default(dict):
    def __missing__(self, key):
      return key

lunch = {"Food": "Pizza"}
print("Lunch: {Food}, {Drink}".format_map(Default(lunch)))

lunch = {"Drink": "Wine"}
print("Lunch: {Food}, {Drink}".format_map(Default(lunch)))

a = "Fitness"
print(a.index("F"))
print(a.index("n"))
print(a.index("ness"))
print(a.index("ess"))
print(a.index("z"))   #Error

c = "Fitness"
print(c.isalnum())

c = "123"
print(c.isalnum())

c = "1.23"
print(c.isalnum())

c = "$*%!!!"
print(c.isalnum())

c = "0.34j"
print(c.isalnum())

c = "Fitness"
print(c.isalpha())

c = "123"
print(c.isalpha())

c = "$*%!!!"
print(c.isalpha())

c = "123"
print(c.isdecimal())

c = u"\u00B2"
print(c.isdecimal())

c = "1.23"
print(c.isdecimal())

c = "u123"
print(c.isdecimal())

c = "Fitness"
print(c.isdecimal())

c = "$*%!!!"
print(c.isdecimal())

c = "123"
print(c.isdigit())

c = u"\u00B2"
print(c.isdigit())

c = "1.23"
print(c.isdigit())

c = "u123"
print(c.isdigit())

c = "Fitness"
print(c.isdigit())

c = "$*%!!!"
print(c.isdigit())

a = "123"
print(a.isidentifier())

a = "_user_123"
print(a.isidentifier())

a = "_user-123"
print(a.isidentifier())

a = "Homer"
print(a.isidentifier())

a = "for"
print(a.isidentifier())

a = " "
print(a.islower())

a = "123"
print(a.islower())

a = "_user_123"
print(a.islower())

a = "Homer"
print(a.islower())

a = "HOMER"
print(a.islower())

a = "homer"
print(a.islower())

a = "HOMER"
a = a.casefold() #Force lowercase
print(a.islower())

c = "123"
print(c.isnumeric())

c = u"\u00B2"
print(c.isnumeric())

c = "1.23"
print(c.isnumeric())

c = "u123"
print(c.isnumeric())

c = "Fitness"
print(c.isnumeric())

c = "$*%!!!"
print(c.isnumeric())

a = ""
print(a.isprintable())

a = " "
print(a.isprintable())

a = u"\u00B2"
print(a.isprintable())

a = "Bart"
print(a.isprintable())

a = "\t"
print(a.isprintable())

a = "\r\n"
print(a.isprintable())

a = "Bart \r"
print(a.isprintable())

a = ""
print(a.isspace())

a = " "
print(a.isspace())

a = "Bart"
print(a.isspace())

a = "\t"
print(a.isspace())

a = "\r\n"
print(a.isspace())

a = "Bart \r"
print(a.isspace())

a = ""
print(a.istitle())

a = " "
print(a.istitle())

a = " t"
print(a.istitle())

a = " T"
print(a.istitle())

a = "Tea"
print(a.istitle())

a = "Tea and Coffee"
print(a.istitle())

a = "Tea And Coffee"
print(a.istitle())

a = "1. Tea & Coffee \r"
print(a.istitle())

a = " "
print(a.isupper())

a = "123"
print(a.isupper())

a = "_USER_123"
print(a.isupper())

a = "Homer"
print(a.isupper())

a = "HOMER"
print(a.isupper())

a = "homer"
print(a.isupper())

a = "HOMER"
a = a.casefold() #Force lowercase
print(a.isupper())

a = "-"
print(a.join("123"))

a = "."
print(a.join("USA"))

a = ". "
print(a.join(("Dr", "Who")))

a = "bee" 
b = a.ljust(12, "-")
print(b)

a = "BEE"
print(a.lower())

a = "      Bee      "
print(a.lstrip(), "!")

a = "-----Bee-----"
print(a.lstrip("-"))

Bee       !
Bee-----

frm = "SecrtCod"
to = "12345678"
trans_table = str.maketrans(frm, to)
secret_code = "Secret Code".translate(trans_table)
print(secret_code)

a = "Python-program"

print(a.partition("-"))
print(a.partition("."))

a = "Tea bag. Tea cup. Tea leaves."

print(a.replace("Tea", "Coffee"))
print(a.replace("Tea", "Coffee", 2))

a = "Yes Fitness"

print(a.rfind("Y"))
print(a.rfind("e"))
print(a.rfind("s"))
print(a.rfind("ss"))
print(a.rfind("y"))
print(a.rfind("z"))
print(a.rfind("Homer"))

a = "Yes Fitness"

print(a.rindex("Y"))
print(a.rindex("e"))
print(a.rindex("s"))
print(a.rindex("ss"))
print(a.rindex("y"))
print(a.rindex("z"))
print(a.rindex("Homer"))

a = "bee" 
b = a.rjust(12, "-")
print(b)

a = "Homer-Jay-Simpson"

print(a.rpartition("-"))
print(a.rpartition("."))

a = "Homer Jay Simpson"
print(a.rsplit())

a = "Homer-Jay-Simpson"
print(a.rsplit(sep="-",maxsplit=1))

a = "      Bee      "
print(a.rstrip(), "!")

a = "-----Bee-----"
print(a.rstrip("-"))

a = "Homer Jay Simpson"
print(a.split())

a = "Homer-Jay-Simpson"
print(a.split(sep="-",maxsplit=1))

a = "Homer,,Bart,"
print(a.split(","))

a = "Homer,,Bart"
print(a.split(",", maxsplit=1))

a = "Homer<>Bart<>Marge"
print(a.split("<>"))

a = "Tea\n\nand coffee\rcups\r\n"

print(a.splitlines())
print(a.splitlines(keepends=True))

a = "Homer"
print(a.startswith("H"))
print(a.startswith("h"))
print(a.startswith("Homer"))
print(a.startswith("z"))
print(a.startswith("om", 1, 3))

a = "      Bee      "
print(a.strip(), "!")

a = "-----Bee-----"
print(a.strip("-"))

a = "Homer Simpson"
print(a.swapcase())

a = "tea and coffee"
print(a.title())

a = "TEA AND COFFEE"
print(a.title())

frm = "SecrtCod"
to = "12345678"
trans_table = str.maketrans(frm, to)
secret_code = "Secret Code".translate(trans_table)
print(secret_code)

a = "bee"
print(a.upper())

a = "36"
print(a.zfill(5))

a = "-36"
print(a.zfill(5))

a = "+36"
print(a.zfill(5))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

string = "hello world"

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

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

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

Функции ord и len

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

print(ord("A"))     # 65

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

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

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

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

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

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

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

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

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

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

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

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

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

• isalpha(): возвращает True, если строка состоит только из алфавитных символов

• islower(): возвращает True, если строка состоит только из символов в нижнем регистре

• isupper(): возвращает True, если все символы строки в верхнем регистре

• isdigit(): возвращает True, если все символы строки — цифры

• isnumeric(): возвращает True, если строка представляет собой число

• startswith(str): возвращает True, если строка начинается с подстроки str

• endswith(str): возвращает True, если строка заканчивается на подстроку str

• lower(): переводит строку в нижний регистр

• upper(): переводит строку в вехний регистр

• title(): начальные символы всех слов в строке переводятся в верхний регистр

• capitalize(): переводит в верхний регистр первую букву только самого первого слова строки

• lstrip(): удаляет начальные пробелы из строки

• rstrip(): удаляет конечные пробелы из строки

• strip(): удаляет начальные и конечные пробелы из строки

• ljust(width): если длина строки меньше параметра width, то справа от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по левому краю

• rjust(width): если длина строки меньше параметра width, то слева от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по правому краю

• center(width): если длина строки меньше параметра width, то слева и справа от строки равномерно добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по центру

• find(str[, start [, end]): возвращает индекс подстроки в строке. Если подстрока не найдена, возвращается число -1

• replace(old, new[, num]): заменяет в строке одну подстроку на другую

• split([delimeter[, num]]): разбивает строку на подстроки в зависимости от разделителя

• join(strs): объединяет строки в одну строку, вставляя между ними определенный разделитель

Например, если мы ожидаем ввод с клавиатуры числа, то перед преобразованием введенной строки в число можно проверить, с помощью метода isnumeric() введено ли в действительности число, и если так, то выполнить операцию преобразования:

string = input("Введите число: ")
if string.isnumeric():
    number = int(string)
    print(number)

Проверка, начинается или оканчивается строка на определенную подстроку:

file_name = "hello.py"

starts_with_hello = file_name.startswith("hello")   # True
ends_with_exe = file_name.endswith("exe")           # False

Удаление пробелов в начале и в конце строки:

string = "   hello  world!  "
string = string.strip()
print(string)           # hello  world!

Дополнение строки пробелами и выравнивание:

print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

Консольный вывод:

iPhone 7:      52000
Huawei P10:      36000

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

Для поиска подстроки в строке в Python применяется метод find(), который возвращает индекс первого вхождения подстроки в строку и имеет три формы:

• find(str): поиск подстроки str ведется с начала строки до ее конца

• find(str, start): параметр start задает начальный индекс, с которого будет производиться поиск

• find(str, start, end): параметр end задает конечный индекс, до которого будет идти поиск

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

welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# поиск с 10-го индекса
index = welcome.find("wor",10)
print(index)       # 21

# поиск с 10 по 15 индекс
index = welcome.find("wor",10,15)
print(index)       # -1

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

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

• replace(old, new): заменяет подстроку old на new

• replace(old, new, num): параметр num указывает, сколько вхождений подстроки old надо заменить на new

phone = "+1-234-567-89-10"

# замена дефисов на пробел
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# удаление дефисов
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# замена только первого дефиса
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

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

Метод split() разбивает строку на список подстрок в зависимости от разделителя. В качестве разделителя может выступать любой символ или последовательность символов. Данный метод имеет следующие формы:

• split(): в качестве разделителя используется пробел

• split(delimeter): в качестве разделителя используется delimeter

• split(delimeter, num): параметр num указывает, сколько вхождений delimeter используется для разделения. Оставшаяся часть строки добавляется в список без разделения на подстроки

text = "Это был огромный, в два обхвата дуб, с обломанными ветвями и с обломанной корой"
# разделение по пробелам
splitted_text = text.split()
print(splitted_text)
print(splitted_text[6])     # дуб,

# разбиение по запятым
splitted_text = text.split(",")
print(splitted_text)
print(splitted_text[1])     # в два обхвата дуб

# разбиение по первым пяти пробелам
splitted_text = text.split(" ", 5)
print(splitted_text)        
print(splitted_text[5])     # обхвата дуб, с обломанными ветвями и с обломанной корой

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

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

words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"]

# разделитель - пробел
sentence = " ".join(words)
print(sentence)  # Let me speak from my heart in English

# разделитель - вертикальная черта
sentence = " | ".join(words)
print(sentence)  # Let | me | speak | from | my | heart | in | English

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

word = "hello"
joined_word = "|".join(word)
print(joined_word)      # h|e|l|l|o

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

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

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

Для создания строки в Python существует три способа.

'одинарные кавычки в строке'

2) В двойных кавычках

"двойные кавычки в строке"

3) В тройных одинарных или двойных кавычках

'''строка_1
строка_2
строка_3'''
'строка_1\nстрока_2\nстрока_23\n' // после нажатия ENTER

print(‘строка_1\nстрока_2\nстрока_23\n’)

// выведет на экране
строка_1
строка_2
строка_3

Последний способ применяется для создания многострочной строки. Когда часть строки нужно перенести на новую строку. Внутри программы на месте переноса строк, Python добавляет символ \n. При выводе на экран многострочной строки, в параметрах print(‘строка_1\nстрока_2\nстрока_23\n’), передается вся эта конструкция.

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

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

В Python допускается создание пустой строки.

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

Операция конкатенация (concatenate) объединяет несколько строк в одну.

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

Как преобразовать число в строку

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

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

Как быстро выполнить операцию повторения строки? Очень просто — умножить строку на число повторений.

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

Операция по вычислению длины строки, довольно часто применяется в программировании. Название функции len — сокращенное от анг. слова length (длина). Функция len() вычисляет количество символов в строке вместе с пробелами. Буквы, знаки пунктуации, пробелы в строке — все это символы.

Поиск подстроки в строке в Python

С помощью команды in, можно проверить содержится ли подстрока (символ/ы) в строке, ответом будет истина / ложь.

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

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

'xy' > 'abc'
True // верно

Здесь у вас наверняка возник вопрос: «Ведь буква «a» стоит выше по алфавиту, чем «x»? В чем подвох? Выведем кодировку первых символов у двух строк. Число 120 явно больше, чем 97.

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

Заключение

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

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

• Создано 28.10.2019 10:23:57
• Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

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

Манипуляция строк в Python — PythonForBeginners.com

Последнее обновление: 20 мая 2020 г.

Обзор

Строка — это список символов по порядку.

Символ — это все, что вы можете набрать на клавиатуре одним нажатием клавиши,
— это буква, цифра или обратный слеш.

Строки могут иметь пробелы:

  "Привет, мир".  

Пустая строка — это строка, содержащая 0 символов.

Строки Python неизменны

Python распознает как строки все, что разделено кавычками
(”” или ‘‘).

String Manipulation

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

Создание

  слово = "Hello World"

>>> напечатать слово
Hello World  

Доступ к

Используйте [] для доступа к символам в строке

  слово = "Hello World"
буква = слово [0]

>>> распечатать письмо
Н  

Длина

  слово = "Hello World"

>>> лен (слово)
11  

Нахождение

  word = "Hello World" >>> напечатать слово.count ('l') # считать, сколько раз l в строке
3

>>> напечатать word.find ("H") # найти слово H в строке
0

>>> print word.index ("World") # найти буквы World в строке
6  

Граф

  с = "Подсчет, количество пробелов"

>>> печать s.count ('')
8  

Нарезка

Используйте [#: #], чтобы получить набор букв

Имейте в виду, что Python, как и многие другие языки, начинает считать с 0 !!

  слово = "Hello World"

напечатать слово [0] # выбрать один символ слова
напечатайте слово [0: 1] # получите один символ слова (как выше)
напечатайте слово [0: 3] # получите первые три символа
напечатать слово [: 3] # получить первые три символа
напечатать слово [-3:] # получить последние три символа
напечатайте слово [3:] # получите все, кроме трех первых символов
напечатать слово [: - 3] # взять все, кроме трех последних символов

слово = "Привет, мир"

слово [начало: конец] # элементы начинаются с конца-1
word [start:] # элементы начинаются с остальной части списка
word [: end] # элементы от начала до конца-1
слово [:] # копия всего списка  

Split Strings

  слово = "Hello World"

>>> слово.split ('') # Разделить пробелами
[«Привет», «Мир»]  

Начало / окончание

  слово = "привет мир"

>>> word.startswith ("H")
Правда

>>> word.endswith ("d")
Правда

>>> word.endswith ("w")
Ложь  

Повторяющиеся струны

  print "." * 10 # печатает десять точек

>>> распечатать "." * 10
..........
  

Замена

  слово = "Hello World"

>>> word.replace («Привет», «До свидания»)
«Прощай, мир»  

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

  string = "Hello World"

>>> распечатать строку.Верхняя ()
ПРИВЕТ МИР

>>> распечатать string.lower ()
Привет мир

>>> распечатать string.title ()
Привет мир

>>> распечатать string.capitalize ()
Привет мир

>>> распечатать string.swapcase ()
ПРИВЕТ ВОРЛД  

Реверс

  string = "Hello World"

>>> print '' .join (перевернутый (строка))
д о л о л л е х  

Газа

Строки Python имеют методы strip (), lstrip (), rstrip () для удаления
любого символа

  message1 = 'привет' + '' + 'world'
печать (message1)
-> Привет, мир
  

  message2a = 'привет' * 3
message2b = 'мир'
распечатать (message2a + message2b)
-> привет привет привет мир
  

  message3 = 'привет'
message3 + = ''
message3 + = 'мир'
печать (message3)
-> Привет мир
  

  message4 = 'привет' + '' + 'world'
печать (Len (message4))
-> 11
  

  message5 = "Привет, мир"
message5a = message5.find ("worl")
печать (message5a)
-> 6