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

Как создать строку в питоне

  • автор:

Строки в Python 3. Введение в работу со строками.

Строки в Python 3

Строки (strings) в Python представляют собой последовательности из одного или более знаков (букв, цифр, символов). И хотя мы можем использовать эту последовательность в каких-то операциях, сама она является неизменной. То есть строку нельзя изменить, не создав при этом другой объект, занимающий иной адрес в памяти.

Благодаря широкому распространению текста в повседневной жизни, строка является важным типом данных, присутствующим в мире программирования.

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

Создание строк и вывод их на экран

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

'Это строка заключена в одинарные кавычки'
"Это строка заключена в двойные кавычки"

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

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

print("Давайте выведем на экран эту строку!") Давайте выведем на экран эту строку!

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

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

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

Давайте соединим строки «Sammy» и «Shark» вместе с помощью функции print() :

print("Sammy" + "Shark") SammyShark

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

print("Sammy" + 27) TypeError: Can't convert 'int' object to str implicitly

Если бы мы захотели создать строку «Sammy27» , мы могли бы это сделать поставив число 27 в кавычки «27» , таким образом превратив его из целого числа в строку. Преобразование числа в строку может быть полезным, когда мы, например, имеем дело с индексами или телефонными номерами. Например, когда нам нужно объединить телефонный код страны и телефонный номер, но при этом мы не хотим их складывать .

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

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

Однажды у вас могут возникнуть обстоятельства, при которых вы захотите использовать Python для автоматизации некоторых задач. И одной из таких задач может стать многократное повторение строки в тексте. Для того чтобы это осуществить, потребуется воспользоваться оператором * , который, как и оператор + , отличается от того, что используется вместе с числами. При использовании с одной строкой и одним числом * становится оператором повторения, а не умножения. Он лишь повторяет заданный текст указанное число раз.

Давайте выведем на экран «Sammy» 9 раз с помощью оператора * .

print("Sammy" * 9) SammySammySammySammySammySammySammySammySammy

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

Сохранение строк в качестве значения для переменных

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

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

my_str = "Sammy likes declaring strings."

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

print(my_str)

И получим следующий вывод:

Sammy likes declaring strings.

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

Заключение

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

Строки. Функции и методы строк

Python 3 логотип

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

Я постарался собрать здесь все строковые методы и функции, но если я что-то забыл — поправляйте.

Базовые операции

  • Конкатенация (сложение)

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

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

Таблица «Функции и методы строк»

Функция или метод Назначение
S = ‘str’; S = «str»; S = »’str»’; S = «»»str»»» Литералы строк
S = «s\np\ta\nbbb» Экранированные последовательности
S = r»C:\temp\new» Неформатированные строки (подавляют экранирование)
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 в комментарий заключайте его в теги

Строки

Строка представляет последовательность символов в кодировке Unicode, заключенных в кавычки. Причем для определения строк Python позволяет использовать как одинарные, так и двойные кавычики:

message = "Hello World!" print(message) # Hello World! name = 'Tom' print(name) # Tom

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

text = ("Laudate omnes gentes laudate " "Magnificat in secula ") print(text)

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

''' Это комментарий ''' text = '''Laudate omnes gentes laudate Magnificat in secula Et anima mea laudate Magnificat in secula ''' print(text)

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

Управляющие последовательности в строке

Строка может содержать ряд специальных символов - управляющих последовательностей или escape-последовательности. Некоторые из них:

  • \ : позволяет добавить внутрь строки слеш
  • \' : позволяет добавить внутрь строки одинарную кавычку
  • \" : позволяет добавить внутрь строки двойную кавычку
  • \n : осуществляет переход на новую строку
  • \t : добавляет табуляцию (4 отступа)

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

text = "Message:\n\"Hello World\"" print(text)

Консольный вывод программы:

Message: "Hello World"

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

path = "C:\python\name.txt" print(path)

Здесь переменная path содержит некоторый путь к файлу. Однако внутри строки встречаются символы "\n", которые будут интерпретированы как управляющая последовательность. Так, мы получим следующий консольный вывод:

C:\python ame.txt

Чтобы избежать подобной ситуации, перед строкой ставится символ r

path = r"C:\python\name.txt" print(path)

Вставка значений в строку

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

userName = "Tom" userAge = 37 user = f"name: age: " print(user) # name: Tom age: 37

В данном случае на место будет вставляться значение переменной userName. Аналогично на вместо будет вставляться значение переменной userAge.

Обращение к символам строки

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

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"

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

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

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

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

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

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

  • 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

Объединение строк

Одной из самых распространенных операций со строками является их объединение или конкатенация. Для объединения строк применяется операция сложения:

name = "Tom" surname = "Smith" fullname = name + " " + surname print(fullname) # Tom Smith

С объединением двух строк все просто, но что, если нам надо сложить строку и число? В этом случае необходимо привести число к строке с помощью функции str() :

name = "Tom" age = 33 info = "Name: " + name + " Age: " + str(age) print(info) # Name: Tom Age: 33

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

Для повторения строки определенное количество раз применяется операция умножения:

print("a" * 3) # aaa print("he" * 4) # hehehehe

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

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

str1 = "1a" str2 = "aa" str3 = "Aa" print(str1 > str2) # False, так как первый символ в str1 - цифра print(str2 > str3) # True, так как первый символ в str2 - в нижнем регистре

Поэтому строка "1a" условно меньше, чем строка "aa". Вначале сравнение идет по первому символу. Если начальные символы обоих строк представляют цифры, то меньшей считается меньшая цифра, например, "1a" меньше, чем "2a". Если начальные символы представляют алфавитные символы в одном и том же регистре, то смотрят по алфавиту. Так, "aa" меньше, чем "ba", а "ba" меньше, чем "ca". Если первые символы одинаковые, в расчет берутся вторые символы при их наличии. Зависимость от регистра не всегда желательна, так как по сути мы имеем дело с одинаковыми строками. В этом случае перед сравнением мы можем привести обе строки к одному из регистров. Функция lower() приводит строку к нижнему регистру, а функция upper() - к верхнему.

str1 = "Tom" str2 = "tom" print(str1 == str2) # False - строки не равны print(str1.lower() == str2.lower()) # True

Функции 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

Python: Формирование строк в циклах

Еще циклы можно использовать, чтобы формировать строки. Подобная задача часто встречается в веб-программировании. Она сводится к обычной агрегации, когда применяется интерполяция или конкатенация.

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

Один из алгоритмов выглядит так:

  1. Строим новую строку
  2. Перебираем символы исходной строки в обратном порядке
def reverse_string(string): index = len(string) - 1 reversed_string = '' while index >= 0: current_char = string[index] reversed_string = reversed_string + current_char # То же самое через интерполяцию # reversed_string = f'' index = index - 1 return reversed_string reverse_string('Game Of Thrones') # 'senorhT fO emaG' # Проверка нейтрального элемента reverse_string('') # '' 

Разберем функцию построчно:

  • index = len(string) - 1 — записываем в новую переменную индекс последнего символа строки (индексы начинаются с нуля)
  • reversed_string = '' — инициализируем строку, куда будем записывать результат
  • while index >= 0: — условие: повторяем тело цикла, пока текущий индекс не дошел до 0 — до первого символа
  • current_char = string[index] — берем из строки символ по текущему индексу
  • reversed_string = reversed_string + current_char — записываем в строку-результат новое значение: текущая строка-результат + новый символ
  • index = index - 1 — обновляем счетчик
  • return reversed_string — когда цикл завершился, возвращаем строку-результат

Советуем скопировать эту функцию в https://replit.com/languages/python3 и поэкспериментировать с ней.

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

Особенно часто забывают, что индекс последнего элемента всегда меньше на единицу размера строки. В строках начальный индекс равен 0 , значит, индекс последнего элемента — len(str) - 1 .

Задание

Реализуйте функцию my_substr() , которая извлекает из переданной строки подстроку указанной длины. Она принимает на вход два аргумента: строку и длину, и возвращает подстроку, начиная с первого символа:

string = 'If I look back I am lost' print(my_substr(string, 1)) # => 'I' print(my_substr(string, 7)) # => 'If I lo' 

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

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

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

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

В моей среде код работает, а здесь нет ��

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

Мой код отличается от решения учителя ��

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

В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.

Прочитал урок — ничего не понятно ��

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

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

Добавить комментарий

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