Всё о строках в Python

 

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

 

Строки в Python принадлежат к типу данных str/string и служат для хранения текстовых данных. 

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

my_string_1 = 'I like Python'
my_string_2 = "You like Python"
my_string_3 = """We like Python"""

 

Сами кавычки являются строковым литералом, которые создают в памяти объект типа string. 

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

 

Например если мы попробуем вначале строки поставить одинарную кавычку, а в конце двойную, то получим ошибку:

my_string_4 = 'He likes Python"
print(my_string_4)

    my_string_4 = 'He likes Python"
                                  ^
SyntaxError: EOL while scanning string literal

 

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

 

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

my_string_1 = "I 'like' Python"
print(my_string_1)
my_string_2 = 'I "like" Python'
print(my_string_2)

I 'like' Python
I "like" Python

 

Второй способ, это экранировать кавычки с помощью обратного слэша: 

my_string_3 = "I \"like\" Python"
print(my_string_3)

I "like" Python

 

Тройные одинарные или двойные кавычки обычно используются для документации в коде, так как имеют интересные свойства. Строки заключённые в них поддерживают многострочность и не требуют использования специального символа \n для переноса строки. Внутри тройных кавычек мы так же можем вставлять двойные или одинарные кавычки:

my_string = """Python
"is"
awesome
"""
print(my_string)

my_string_1 = "Hello \nWorld"
print(my_string_1)

Python
"is"
awesome

Hello 
World

 

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

my_string = "Python"
print(id(my_string))
my_string = "JavaScript"
print(id(my_string))

140050277286512
140050275652464

 

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

 

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

 

 

В операциях со строками функционал этого операнда отличается от работы с числами.

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

my_string = "Python " + "is" + " awesome!"
print(my_string)

Python is awesome!

 

В Python мы так же можем использовать операнд умножения "*" при работе со строками. Операнд умножения дублирует нашу строку умножая её на переданное значение:

my_string = "Go" * 10
print(my_string)

GoGoGoGoGoGoGoGoGoGo

 

Важным свойством строк является их длина. Длину строки мы можем узнать с помощью встроенной функции len() сокращение от слова length, что в переводе с английского означает - длина.

my_string = "Python"
print(len(my_string))

6

 

Обратите внимание, что если передать пустую строку и вывести её длину, мы получим 0 т.е boolean значение False, а если хотя бы поставим пробел, то получим 1 эквивалентную значению True.

my_string = ""
print(len(my_string))
my_string_1 = " "
print(len(my_string_1))

0
1

 

Если вы пока не знакомы с типом данных boolean, не переживайте, позже мы его рассмотрим.

 

Мы уже использовали ранее некоторые так называемые независимые функции такие как print(), type() и id().

my_string = "Python"
print(my_string)
print(type(my_string))
print(id(my_string))

Python
<class 'str'>
139975328428592

 

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

 

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

my_string = "python"
for mth in dir(my_string):
    print(mth)

__add__
__class__
__contains__
__delattr__
__dir__
__doc__
__eq__
__format__
__ge__
__getattribute__
__getitem__
__getnewargs__
__gt__
__hash__
__init__
__init_subclass__
__iter__
__le__
__len__
__lt__
__mod__
__mul__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__rmod__
__rmul__
__setattr__
__sizeof__
__str__
__subclasshook__
capitalize
casefold
center
count
encode
endswith
expandtabs
find
format
format_map
index
isalnum
isalpha
isascii
isdecimal
isdigit
isidentifier
islower
isnumeric
isprintable
isspace
istitle
isupper
join
ljust
lower
lstrip
maketrans
partition
replace
rfind
rindex
rjust
rpartition
rsplit
rstrip
split
splitlines
startswith
strip
swapcase
title
translate
upper
zfill

 

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

 

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

 

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

 

Есть как простые методы например  upper() и lower() которые приводят строку к разным регистрам, или title() который возвращает первую заглавную букву:

my_string = "python"
my_string = my_string.upper()
print(my_string)
my_string = my_string.lower()
print(my_string)
my_string = my_string.title()
print(my_string)

PYTHON
python
Python

 

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

 

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

my_string = "I like PHP"
print(my_string)
my_string = my_string.replace('PHP', 'Python')
print(my_string)

I like PHP
I like Python

 

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

my_string = "I like PHP"
print(my_string)
my_string.replace('PHP', 'Python')
print(my_string)

I like PHP
I like PHP

 

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

 

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

my_string = "I like Python"
my_string = my_string.split(' ')
print(my_string)

['I', 'like', 'Python']

Например разделив нашу строку по пробелу, мы получим список из трёх объектов.

 

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

my_string = "I " + "like" + " Python"
print(my_string)

my_string = my_string.split(' ')
my_string = '-'.join(my_string)
print(my_string)

I like Python
I-like-Python

 

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

 

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

my_string = "I like Python!       "
my_string = my_string.strip()
print(my_string)

my_string = my_string.strip('!')
print(my_string)

I like Python!
I like Python

 

У него есть несколько похожих методов таких как lstrip() что означает обрезать слева и rstrip() соответственно обрезать справа: 

my_string = "@I like Python!"
print(my_string)
my_string = my_string.lstrip("@")
print(my_string)
my_string = my_string.rstrip("!")
print(my_string)

@I like Python!
I like Python!
I like Python

 

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

 

 

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

name = 'Андрей'
my_string = f'Привет {name}!'
print(my_string)

Привет Андрей!

 

Например у нас есть переменная name со значением "Андрей" и строка my_string = со значением "Привет !", для того, чтобы подставить в нашу строку переменную name, мы вначале строки указываем букву f, а внутрь строки передаём в фигурных скобках переменную name. Таким образом мы можем передавать сколько угодно значений в строку, подставляя в нужные места переменные:

name = 'Андрей'
my_string = f'Привет {name}!'
print(my_string)

name_1 = 'Кристина'
name_2 = "Влад"
my_string = f'Привет {name}, {name_1}, {name_2}!'
print(my_string)

Привет Андрей!
Привет Андрей, Кристина, Влад!

 

Следующий способ форматирования строк, через строковый метод format(). Мы не указываем вначале букву f, а передаём значения в виде аргументов в сам метод:

name = 'Анна'
my_string = 'Привет {}'.format(name)
print(my_string)

Привет Анна

 

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

name = 'Анна'
my_string = 'Привет {1}{0}'.format(name, "!")
print(my_string)

Привет !Анна

 

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

 

Либо можем передать значения присваивая их через именованные аргументы:

name = 'Анна'
my_string = 'Привет {important}{name}'.format(name=name, important='!')
print(my_string)

Привет !Анна

 

И последний, весьма старый способ который вы можете встретить в своей практике это форматирование через оператор процента:

name = 'Алекс'
my_string = 'Привет %s'
print(my_string % name)

Привет Алекс

 

Данный метод форматирования постепенно исчезает из кода, но тем неменее встречается в книгах и старых проектах.

 

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

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

 

 

Например у нас есть переменная my_string со значением "Python is awesome", при обращении к переменной my_string мы получаем строку целиком:

my_string = "Python is awesome"
print(my_string)

Python is awesome

 

Каждый символ нашей строки имеет свой индекс, начиная с 0. Так у P будет индекс равный 0, у Y равный 1 и так далее. Для получения конкретного символа мы должны обратиться к его индексу используя квадратные скобки, передавая внутрь индекс:

my_string = "Python is awesome"
# print(my_string)
print(my_string[0])
print(my_string[1])
print(my_string[2])
print(my_string[3])
print(my_string[4])
print(my_string[5])
print(my_string[6])

P
y
t
h
o
n

 

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

 

Мы можем воспользоваться уже знакомой нам функцией len() и напечатать длину нашей строки равную 17.

my_string = "Python is awesome"
print(len(my_string))

17

 

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

my_string = "Python is awesome"
print(my_string[17])

    print(my_string[17])
IndexError: string index out of range

 

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

 

Функция len() начинает свой отсчёт с 1, именно поэтому показывает длину равную 17. Но помните что индексирование строк начинается с 0, т.е на единицу меньше чем начало отсчёта функции len(). 

 

Для того, чтобы обратиться к последнему символу во многих языках в том числе и в Python мы можем использовать конструкцию my_string[len(my_string) - 1]:

my_string = "Python is awesome"
print(my_string[len(my_string) - 1])

e

 

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

 

Нумерация отрицальтельных индексов начинается с правого края и минус единицы. Т.е буква "e" имеет индекс -1, "m" -2, "o" -3 и так далее справа налево:

my_string = "Python is awesome"
print(my_string[-1])
print(my_string[-2])
print(my_string[-3])

e
m
o

 

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

 

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

 

Вернёмся к нашей строке. Например нам нужно вырезать слово Python. Мы как и прежде обращаемся к строке, затем ставим квадратные скобки, указываем начальный индекс равный 0, т.е с какой буквы нам нужно отрезать и через двоеточие указываем индекс буквы по которую нужно получить срез, буква "n" имеет индекс равный 5.

my_string = "Python is awesome"
print(my_string[0:5])

Pytho

 

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

my_string = "Python is awesome"
print(my_string[0:6])

Python

 

Давайте ещё раз попробуем получить срез, на этот раз возьмём слово "is", "i" у нас имеет индекс равный 7, а "s" под 8, получается нам нужно указать срез с 7 по 8 индекс, но не забываем прибавить единицу и получается с 7 по 9.

my_string = "Python is awesome"
print(my_string[7:9])

is

 

Хорошо.

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

my_string = "Python is awesome"
print(my_string[:])

Python is awesome

 

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

my_string = "Python is awesome"
print(my_string[:13])

Python is awe

 

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

 

Шаг можно указать через двоеточие. Давайте создадим строку с цифрами для большей наглядности. И например укажем шаг равный 2 для всей нашей строки, в результате мы получим только нечётные числа:

my_string = "123456789"
print(my_string[::2])

13579

 

Т.е получаем единицу, прибавляем к ней шаг равный 2 получаем 3, далее прибавляем шаг равный 2 и получаем 5, 7 и так далее.

 

Если мы не укажем интервал и поставим шаг равный -1 то получим перевернутую строку:

my_string = "123456789"
print(my_string[::-1])

987654321

 

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

 

У нас будет с вами много практики и не переживайте если вы что-то не уловили. Enjoy!