Введение
В этой лабораторной работе вы получите практический опыт работы со строками (strings) в Python — фундаментальным типом данных. Вы начнете с понимания основ строк, включая их создание, неизменяемость (immutability) и доступ к отдельным символам с использованием как положительной, так и отрицательной индексации.
Опираясь на эту основу, вы научитесь извлекать подстроки с помощью срезов (slicing), использовать различные строковые операторы и управляющие (escape) символы для манипуляций и специального форматирования, а также изучите различные методы форматирования строк. Наконец, вы углубитесь в общие строковые методы для выполнения таких операций, как поиск, замена и изменение содержимого строк.
Понимание основ строк и индексации
На этом шаге вы изучите фундаментальные концепции строк в Python, включая то, как их создавать и получать доступ к отдельным символам с помощью индексации. Строки — это последовательности символов и являются одним из наиболее распространенных типов данных. Вы можете создавать строки, используя одинарные кавычки ('...') или двойные кавычки ("...").
Ключевой характеристикой строк Python является их неизменяемость (immutable), что означает, что их содержимое не может быть изменено после создания. Любая операция, которая, казалось бы, изменяет строку, на самом деле создает новую.
Давайте рассмотрим это. В WebIDE откройте файл string_basics.py из каталога ~/project в проводнике файлов слева. Добавьте в него следующий код:
## string_basics.py
## Строки неизменяемы. Присвоение новой строки переменной
## создает новый строковый объект с новым адресом в памяти.
a = "hello"
print(f"Value: {a}, ID: {id(a)}")
a = "hi"
print(f"Value: {a}, ID: {id(a)}")
Чтобы запустить скрипт, откройте терминал в WebIDE (Terminal -> New Terminal) и выполните следующую команду:
python ~/project/string_basics.py
Вы увидите вывод, похожий на этот, где значения ID различны, что подтверждает создание нового строкового объекта.
Value: hello, ID: <placeholder>
Value: hi, ID: <placeholder>
Теперь давайте изучим индексацию строк. Вы можете получить доступ к отдельным символам, используя их индекс (позицию). В Python индексация начинается с 0 для первого символа.
Измените файл string_basics.py, чтобы включить положительную индексацию:
## string_basics.py
a = "Hello"
## Положительная индексация (с начала)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])
## Доступ к несуществующему индексу вызовет IndexError.
## print(a[5])
Сохраните файл и запустите его снова:
python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o
Python также поддерживает отрицательную индексацию, которая обращается к символам с конца строки. Последний символ имеет индекс -1, предпоследний — -2 и так далее.
Добавьте примеры отрицательной индексации в string_basics.py:
## string_basics.py
a = "Hello"
## Положительная индексация (с начала)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])
## Отрицательная индексация (с конца)
print("\nNegative Indexing:")
print(a[-5])
print(a[-4])
print(a[-3])
print(a[-2])
print(a[-1])
## Поскольку строки неизменяемы, вы не можете изменить символ.
## Следующая строка вызовет TypeError: 'str' object does not support item assignment
## a[0] = "J"
Сохраните файл и запустите его в последний раз для этого шага:
python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o
Negative Indexing:
H
e
l
l
o
Выполнение срезов строк (String Slicing)
На этом шаге вы узнаете, как извлекать подстроки из строки с помощью срезов. В то время как индексация позволяет получить один символ, срезы позволяют получить последовательность символов.
Базовый синтаксис для среза: string[start:end]. Это извлекает часть строки, начиная с индекса start и до, но не включая, индекса end.
Откройте файл string_slicing.py из каталога ~/project. Добавьте следующий код для демонстрации базовых срезов:
## string_slicing.py
a = "Hello World"
## Срез от индекса 0 до (но не включая) индекса 5
print(a[0:5])
## Срез от индекса 6 до конца строки
print(a[6:])
## Срез от начала до (но не включая) индекса 5
print(a[:5])
## Использование отрицательных индексов для среза
print(a[-5:-2])
## Получение копии всей строки
print(a[:])
Сохраните файл и запустите его из терминала:
python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
Срезы также могут принимать третий параметр, step (шаг), с синтаксисом string[start:end:step]. Значение step определяет интервал между символами в срезе.
Измените string_slicing.py, чтобы включить примеры с шагом:
## string_slicing.py
a = "Hello World"
## ... (предыдущий код) ...
b = "0123456789"
## Получить каждый второй символ от начала до конца
print(b[::2])
## Получить символы от индекса 1 до 7 с шагом 3
print(b[1:7:3])
## Отрицательный шаг меняет направление. Это переворачивает всю строку.
print(b[::-1])
## Развернуть от индекса 7 до (но не включая) индекса 2
print(b[7:2:-1])
Сохраните файл и запустите его снова:
python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543
Срезы "прощают" ошибки и автоматически обрабатывают индексы, выходящие за границы, что предотвращает ошибки.
Добавьте эти последние строки в string_slicing.py, чтобы увидеть это поведение:
## string_slicing.py
a = "Hello World"
## ... (предыдущий код) ...
b = "0123456789"
## ... (предыдущий код) ...
## Срезы с индексами, выходящими за границы
c = "Python"
## Конечный индекс больше длины строки, но это работает корректно.
print(c[2:100])
## Начальный индекс находится до начала строки, но это работает корректно.
print(c[-100:4])
Сохраните и запустите скрипт:
python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543
thon
Pyth
Использование строковых операторов и управляющих символов (Escape Characters)
На этом шаге вы узнаете об общих операторах, используемых со строками, и о том, как использовать управляющие последовательности для представления специальных символов.
Python предоставляет несколько операторов для манипулирования строками. Операторы in и not in проверяют наличие подстрок, + объединяет (конкатенирует) строки, а * повторяет строку.
Откройте файл string_operators.py в WebIDE и добавьте следующий код:
## string_operators.py
## Оператор 'in' проверяет, существует ли подстрока внутри строки
print('e' in 'Hello')
print('x' in 'Hello')
## Оператор 'not in' является противоположностью 'in'
print('e' not in 'Hello')
print('x' not in 'Hello')
## Конкатенация (+) соединяет две строки
print('Hello' + ' ' + 'World')
## Повторение (*) повторяет строку заданное количество раз
print('=' * 20)
print('Go! ' * 3)
Сохраните файл и запустите его:
python ~/project/string_operators.py
True
False
False
True
Hello World
====================
Go! Go! Go!
Далее рассмотрим управляющие последовательности (escape characters). Это специальные последовательности, начинающиеся с обратной косой черты (\), которые представляют непечатаемые или специальные символы.
Откройте файл escape_characters.py и добавьте следующий код:
## escape_characters.py
## Используйте \' или \" для включения кавычек внутрь строки
print('It\'s a beautiful day.')
print("He said, \"Python is fun!\"")
## \n создает новую строку
print("First line\nSecond line")
## \t создает горизонтальную табуляцию
print("Column1\tColumn2\tColumn3")
## \\ представляет собой литеральную обратную косую черту
print("This is a backslash: \\")
## Сырая строка (raw string), с префиксом 'r', рассматривает обратные косые черты как литеральные символы.
## Это очень полезно для путей к файлам и регулярных выражений.
print("A normal string: C:\\Users\\new_folder")
print(r"A raw string: C:\Users\new_folder")
Сохраните файл и запустите его:
python ~/project/escape_characters.py
It's a beautiful day.
He said, "Python is fun!"
First line
Second line
Column1 Column2 Column3
This is a backslash: \
A normal string: C:\Users\new_folder
A raw string: C:\Users\new_folder
Форматирование строк (String Formatting)
На этом шаге вы узнаете о современных и эффективных способах форматирования строк в Python. Это имеет решающее значение для создания динамичного и читаемого вывода путем встраивания переменных и выражений внутрь строк.
Хотя вы можете использовать оператор + для конкатенации строк, это становится громоздким при смешивании строк с типами, не являющимися строками, такими как числа, поскольку вам необходимо вручную преобразовывать их с помощью str().
Python предлагает лучшие решения. Наиболее распространенным и рекомендуемым методом является использование f-строк (форматированных строковых литералов).
Форматирование с помощью f-строк
f-строки, представленные в Python 3.6, предоставляют краткий и читаемый способ встраивания выражений внутрь строк. Вы просто добавляете префикс f или F к строке и записываете выражения внутри фигурных скобок {}.
Откройте файл string_formatting.py и добавьте следующий код:
## string_formatting.py
name = "Alice"
age = 30
## Использование f-строки для встраивания переменных
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)
## Вы также можете встраивать выражения напрямую
print(f"In 5 years, I will be {age + 5} years old.")
Сохраните и запустите скрипт:
python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
Спецификаторы формата (Format Specifiers)
f-строки также позволяют контролировать форматирование встроенных значений с помощью спецификаторов формата, которые следуют за двоеточием (:) внутри скобок.
Добавьте следующие примеры в string_formatting.py:
## string_formatting.py
## ... (предыдущий код) ...
pi = 3.14159265
## Форматирование числа с плавающей точкой до 2 знаков после запятой
print(f"The value of pi is approximately {pi:.2f}")
## Дополнение числа ведущими нулями до ширины 8
order_id = 45
print(f"Order ID: {order_id:08}")
## Выравнивание текста в заданном пространстве (ширина 10)
## < (влево), ^ (по центру), > (вправо)
text = "Python"
print(f"'{text:<10}'")
print(f"'{text:^10}'")
print(f"'{text:>10}'")
## Добавление запятой в качестве разделителя тысяч
large_number = 1234567890
print(f"A large number: {large_number:,}")
Сохраните и запустите скрипт снова:
python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python '
' Python '
' Python'
A large number: 1,234,567,890
Метод str.format()
До появления f-строк метод str.format() был предпочтительным способом форматирования строк. Он работает путем размещения заполнителей в виде фигурных скобок {} в строке, а затем передачи значений в метод format().
Добавьте этот пример в конец string_formatting.py:
## string_formatting.py
## ... (предыдущий код) ...
## Использование метода str.format()
item = "moon"
cost = 99.95
statement = "The {} costs {:.2f} dollars.".format(item, cost)
print(statement)
Сохраните и запустите файл, чтобы увидеть результат:
python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python '
' Python '
' Python'
A large number: 1,234,567,890
The moon costs 99.95 dollars.
Хотя str.format() все еще полезен, f-строки, как правило, более читабельны и быстрее.
Изучение общих строковых методов (Common String Methods)
На этом заключительном шаге вы изучите некоторые из наиболее распространенных и полезных встроенных методов для строковых объектов. Эти методы выполняют различные операции, такие как изменение регистра, поиск и замена текста, а также разделение строк на списки.
Помните, что строки являются неизменяемыми (immutable), поэтому эти методы всегда возвращают новую строку и не изменяют исходную.
Откройте файл string_methods.py и добавьте следующий код, чтобы увидеть эти методы в действии:
## string_methods.py
## Методы преобразования регистра
s1 = "Hello, World!"
print(f"Original: '{s1}'")
print(f"Upper case: '{s1.upper()}'")
print(f"Lower case: '{s1.lower()}'")
print(f"Title case: '{s1.title()}'")
print("-" * 20)
## Поиск и замена
s2 = "The quick brown fox jumps over the lazy dog."
print(f"Original: '{s2}'")
## Проверка, начинается ли строка или заканчивается ли она подстрокой
print(f"Starts with 'The': {s2.startswith('The')}")
print(f"Ends with 'dog.': {s2.endswith('dog.')}")
## Нахождение индекса подстроки (-1, если не найдена)
print(f"Index of 'fox': {s2.find('fox')}")
## Замена одной подстроки другой
s3 = s2.replace("brown", "red")
print(f"After replace: '{s3}'")
print("-" * 20)
## Удаление пробелов (stripping whitespace)
s4 = " some whitespace "
print(f"Original: '{s4}'")
## strip() удаляет с обоих концов, lstrip() слева, rstrip() справа
print(f"Stripped: '{s4.strip()}'")
print("-" * 20)
## Разделение (splitting) и объединение (joining)
s5 = "one,two,three,four"
print(f"Original: '{s5}'")
## Разделение строки на список подстрок по разделителю
parts = s5.split(',')
print(f"Split list: {parts}")
## Объединение элементов списка в одну строку с использованием разделителя
s6 = " ".join(parts)
print(f"Joined string: '{s6}'")
Сохраните файл и запустите его из терминала:
python ~/project/string_methods.py
Ваш вывод должен выглядеть следующим образом:
Original: 'Hello, World!'
Upper case: 'HELLO, WORLD!'
Lower case: 'hello, world!'
Title case: 'Hello, World!'
--------------------
Original: 'The quick brown fox jumps over the lazy dog.'
Starts with 'The': True
Ends with 'dog.': True
Index of 'fox': 16
After replace: 'The quick red fox jumps over the lazy dog.'
--------------------
Original: ' some whitespace '
Stripped: 'some whitespace'
--------------------
Original: 'one,two,three,four'
Split list: ['one', 'two', 'three', 'four']
Joined string: 'one two three four'
Это лишь некоторые из множества строковых методов, доступных в Python. Они предоставляют мощные инструменты для обработки и манипулирования текстовыми данными.
Резюме
В этой лабораторной работе вы изучили основные концепции работы со строками в Python. Вы начали с основ, поняв, как создавать строки и осознав их неизменяемую природу (immutable). Вы практиковались в доступе к отдельным символам как с помощью положительной, так и отрицательной индексации, а также извлекали подстроки, используя срезы (slicing) с параметрами начала, конца и шага.
Затем вы изучили строковые операторы для конкатенации (+) и повторения (*) и узнали, как использовать управляющие символы (escape characters) для включения специальных символов в ваши строки. Вы освоили современные методы форматирования строк, сосредоточившись на мощности и читаемости f-строк и их спецификаторов формата, а также ознакомились с методом str.format(). Наконец, вы попрактиковались в использовании общих строковых методов, таких как upper(), lower(), replace(), strip(), split() и join(), для выполнения основных задач по манипулированию текстом.
