Как отделяются строки в питон

Строки в Python

Строка — это последовательность символов.

Символ — это просто одиночный символ. Например, в английском языке 26 символов, букв.

Компьютер работает не с символами, а с числами в двоичной записи. Вы видит на экране символы, но компьютер хранит и обрабатывает их как комбинацию нулей и единиц.

Преобразование символа в число называется кодированием, а обратный процесс — декодированием. О самых известных стандартах кодирования вы, скорее всего, слышали. Это ASCII и Unicode.

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

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

Если заключить набор символов в одинарные '' или двойные "" кавычки с двух сторон, получится строка. В Python можно использовать и тройные кавычки '''''' , но их обычно используют для многострочных строк и строк документации.

# все способы ниже эквиваленты: они делают одно и то же my_string = 'Привет' print(my_string) my_string = "Привет" print(my_string) my_string = '''Привет''' print(my_string) # тройные кавычки позволяют создавать многострочные строки my_string = """Привет, добро пожаловать в мир Python""" print(my_string)

Вывод:

Привет
Привет
Привет
Привет, добро пожаловать 
в мир Python

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

1. По индексу

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

Примечание. Первый элемент в строке (то есть первый символ) Python имеет индекс 0.

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

Если вы попытаетесь получить доступ к символу с индексом, который больше длины строки, Python выдаст ошибку IndexError.

Индекс не обязательно должен быть положительным числом. Python поддерживает и «отрицательную индексацию». Индекс -1 ссылается на последний символ, -2 — на предпоследний и так далее.

2. С помощью среза

Получить доступ к символам в строке можно и с помощью слайсинга (от англ. «нарезание»). Таким способом удобно получать набор символов в заданном диапазоне.

Срезы задаются с помощью квадратных скобов [] и 2-3 аргументов через двоеточие : .

my_collection[старт:стоп:шаг]

string = 'codechick' print('string = ', string) #первый символ print('string[0] = ', string[0]) #последний символ print('string[-1] = ', string[-1]) #срез от 2 до 5 символа print('string[1:5] = ', string[1:5]) #срез от 6 до предпоследнего символа print('string[5:-2] = ', string[5:-2])

Вывод:

string = codechick
string[0] = c
string[-1] = k
string[1:5] = odec
string[5:-2] = hi

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

Помните строку my_string?

# длина строки my_string = 6 символов, а мы пытаемся получить 15 символ
>>> my_string[15] 
. 
IndexError: string index out of range

# индекс должен быть целым числом
>>> my_string[1.5] 
. 
TypeError: string indices must be integers

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

Строка — неизменяемый тип данных. Это значит, что мы не можем изменить элементы строки после создания. Зато можем переназначать разные строки одной и той же переменной.

>>> my_string = 'codechick'
>>> my_string[5] = 'a'
. 
TypeError: 'str' object does not support item assignment

>>> my_string = 'Python' >>> my_string 'Python'

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

>>> del my_string[1]
. 
TypeError: 'str' object does not support item deletion

>>> del my_string
>>> my_string
. 
NameError: name 'my_string' is not defined

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

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

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

Конкатенация — это объединение двух или более строк в одну.

Эту операцию в Python выполняет оператор + . А с помощью оператора * можно повторить строку заданное количество раз — «умножить» строку на число.

string1 = 'Привет, ' string2 ='мир!' # используем + print('string1 + string2 = ', string1 + string2) # используем * print('string1 * 3 =', string1 * 3)

Вывод:

string1 + string2 = Привет, мир!
string1 * 3 = Привет, Привет, Привет,

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

>>> # два строковых литералы записаны вместе >>> 'Привет, ''мир!' 'Привет, мир!' >>> # круглые скобки объединяют строковые литералы >>> s = ('Привет, ' . 'мир') >>> s 'Привет, мир'

Итерирование по строке

В Python можно «пройтись» по строке, то есть перебрать все символы в ней. Для этого нужно использовать цикл for.

count = 0 for letter in 'Привет, мир!': if (letter == 'и'): count += 1 print(count, 'буквы «и» в данной строке') 

Вывод:

2 буквы «и» в данной строке

Проверка на вхождение

В Python можно проверить, находится ли данная подстрока в строке или нет с помощью операторов членства in и not in .

>>> 'chick' in 'codechick' True >>> 'code' not in 'codechick' False

Функции для работы со строками

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

Самые полезные:

• enumerate() — позволяет перебирать строку, отслеживая индекс текущего элемента.
• len() — возвращает длину строки.

string = 'кодер' # enumerate() list_enumerate = list(enumerate(string)) print('list(enumerate(string) = ', list_enumerate) # считаем количество символов print('len(string) = ', len(string))

Вывод:

list(enumerate(string) = [(0, 'к'), (1, 'о'), (2, 'д'), (3, 'е'), (4, 'р')]
len (string) = 5

Методы строк

Разбивает строки по заданном разделителю (по умолчанию — пробел)

«Собирает» строку из списка с разделителем

find(подстрока, начало, конец)

Поиск подстроки в строке. Возвращает индекс первого вхождения слева. Если подстроки в строке нет, возвращает -1

index(подстрока, начало, конец)

Поиск подстроки в строке. Возвращает индекс первого вхождения. Если подстроки в строке нет, возвращает ValueError

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

Проверяет, состоит ли строка из цифр. Возвращает True или False

Проверяет, состоит ли строка из букв. Возвращает True или False

Проверяет, состоит ли строка из символов в нижнем регистре. Возвращает True или False

Проверяет, состоит ли строка из символов в верхнем регистре. Возвращает True или False

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

Преобразует строку к нижнему регистру

Преобразует символ в ASCII-код

Преобразует ASCII-код в символ

>>> "CoDeCHicK".lower() 'codechick' >>> "CoDeCHicK".upper() 'CODECHICK' >>> "Эта инструкция разобьет строку и засунет элемент в список".split() ['Эта', 'инструкция', 'разобьет', 'строку', 'и', 'засунет', 'элемент', 'в', 'список'] >>> ' '.join(['Эта', 'инструкция', 'соберет', 'все', 'слова', 'в', 'одну', 'строку']) 'Эта инструкция соберет все слова в одну строку' >>> 'Счастливого Рождества!r'.find('ож') 13 >>> 'Счастливого Рождества!'.replace('Счастливого', 'Чудесного') 'Чудесного Рождества!'

Как форматировать строки

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

Допустим, нам нужно напечатать на экран такое сообщение: He said, "What's there?" (Он сказал: «Что там?»). Проблема в том, что в этом тексте есть и двойные, и одинарные кавычки (апостроф), поэтому мы не можем использовать их для создания строки — это приведет к ошибке SyntaxError.

>>> print("He said, "What's there?"")
. 
SyntaxError: invalid syntax

>>> print('He said, "What's there?"')
. 
SyntaxError: invalid syntax

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

Есть два способа обойти эту проблему: использовать тройные кавычки или escape-последовательности — их еще иногда называют управляющими последовательностями.

Вот, как это выглядит на практике.

# с помощью тройных кавычке print('''He said, "What's there?"''') # escape-последовательность и одинарные кавычки print('He said, "What\'s there?"') # escape-последовательность и двойные кавычки print("He said, \"What's there?\"") 

Вывод:

He said, "What's there?"
He said, "What's there?"
He said, "What's there?"

Список escape-последовательностей

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

Экранирование обратного слэша

Экранирование одинарной кавычки

Экранирование двойной кавычки

Звуковой сигнал или предупреждение

Возврат на одну позицию

Перенос строки на новую

>>> print("C:\\Python32\\Lib") C:\Python32\Lib >>> print("Это сообщение печатается\на двух строках") Это сообщение печатается на двух строках

Игнорирование управляющих последовательностей

Чтобы Python проигнорировал escape-последовательность в строке, можно написать перед этой строкой r или R .

>>> print("Это \nхороший пример") Это хороший пример >>> print(r"Это \nхороший пример") Это \nхороший пример

Метод format()

Метод format() — очень гибкий и мощный инструмент для форматирования строк. В качестве заполнителей используются фигурные скобки <> .

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

# порядок по умолчанию default_order = "<>, <> и <>".format('Петя','Ваня','Катя') print('\n--- Порядок по умолчанию ---') print(default_order) # порядок с позиционными аргументами positional_order = ", и ".format('Петя','Ваня','Катя') print('\n--- Позиционный порядок ---') print(positional_order) # порядок по ключевым словам keyword_order = ", и ".format(j='Петя',b='Петя',s='Катя') print('\n--- Порядок по ключевым словам ---') print(keyword_order)

Вывод:

--- Порядок по умолчанию ---
Петя, Ваня и Катя

--- Позиционный порядок ---
Ваня, Петя и Катя

--- Порядок по ключевым словам ---
Катя, Ваня и Петя

У метода format() есть дополнительные настройки. Они отделяются от имени поля двоеточием : . Например, строку можно выровнять по левому краю < , по правому краю >или центрировать ее ^ .

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

>>> # форматирование целых чисел >>> "Двоичное запись числа = ".format(12) 'Двоичная запись числа 12 = 1100' >>> # форматирование чисел с плавающей точкой >>> "Экспоненциальное представление: ".format(1566.345) 'Экспоненциальное представление: 1.566345e+03' >>> # округление >>> "Одна треть = ".format(1/3) 'Одна треть = 0.333' >>> # выравнивание строк >>> "|||10>|".format('масло', 'булка', 'колбаса') '|масло | булка | колбаса|'

Строки

Строка представляет последовательность символов в кодировке 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

Строки и функция print в Python

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

"Строка Python."

'Строка Python.'

Это позволяет использовать внутренние кавычки в строках. "Язык программирования 'Python' ". Рассмотрим операции со строками.

1. Функция print() в Python .

Встроенная функция print() выводит свой аргумент в строке текста.

>>> print( 'Hello world!' )
Hello world!
>>> print( "Hello world!" )
Hello world
>>> print( "Hello", 'world!' )
Hello world

В каждом случае аргументом является строка Hello world! Кроме того, print() не выводит кавычки, в которые заключена строка. Строка может быть заключена как в одинарные так и в двойные кавычки. В третьем случае, функция print() , получила список аргументов "Hello" и 'world', разделенных запятыми. Каждый аргумент выводится, отделяясь от следующего пробелом. В итоге во всех трех случаях получается один и тот же результат.

2. Табуляция и разрыв строк в Python.

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

В таблице приведены наиболее часто встречаемые комбинации символов.

Для добавления в текст табуляции используется комбинация символов \t . Разрыв строки добавляется с помощью комбинации символов \n .

>>> print("Python")
Python
>>> print(" \t Python")
Python
>>> print("Языки программирования: \n Python \n Java \n C")
Языки программирования:
Python
Java
C

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

>>> print("Языки программирования: \n\t Python \n\t Java \n\t C")
Языки программирования:
Python
Java
C

3. Изменение регистра символов в строках в Python.

Одной из частых операций, выполняемых со строками - это изменение регистра символов. Например, у нас есть переменная name, в которой сохранена строка "Hello world!". Для преобразования символов к верхнему или нижнему регистру существует несколько методов.

>>> name = "Hello world!"
>>> print(name. title() )
Hello World!
>>> print(name. upper() )
HELLO WORLD!
>>> print(name. lower() )
hello world!

В первом случае за именем переменной в команде print() следует вызов метода title() . Метод - это действие, которое Python выполняет с данными. Точка после name приказывает Python применить метод title() к переменной name. За именем метода всегда следует пара круглых скобок () . Методам для выполнения их работы часто требуется дополнительные данные, и они указываются в скобках. В данный момент дополнительная информация не нужна, поэтому в скобках ничего нет. Метод title() преобразует первый символ каждого слова к верхнему регистру, остальные символы выводятся, как и были. Во втором случае используется метод upper() , в котором все символы преобразовываются к верхнему регистру. В третьем случае в методе lower() идет преобразование всех символов к нижнему регистру.

Метод lower() очень часто используется для хранения данных. Редко при вводе данных все пользователи вводят данные с точным соблюдением регистра. После ввода все данные преобразуются к нижнему регистру и уже затем выводится информация с использованием регистра, наиболее подходящего.

4. F-строки. Форматирование строк в Python.

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

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

Python заменить каждую переменную на ее значение при выводе строки.

>>> name = "Александр"
>>> surname = "Пушкин"
>>> full_name = f" "
>>> print(full_name)
Александр Пушкин

Буква f происходит от слова format, потому что Python форматирует строку, заменяя имена переменных в фигурных скобках на их значения. В итоге выводится строка имя и фамилия.

Если в переменной имя и фамилия записана с маленькой буквы, то на помощь придет метод title() . Так же с помощью f строк можно строить сообщения, которые затем сохраняются в переменной.

>>> name = "александр"
>>> surname = "пушкин"
>>> full_name = f" "
>>> print( f" Русский поэт ! " )
Русский поэт Александр Пушкин!
>>> message = f" Мой любимый поэт "
>>> print(message)
Мой любимый поэт Александр Пушкин

Важно: F-строки впервые появились в Python3.6. Если вы используете более раннею версию, используйте метод format. Что бы использовать метод format(), перечислите переменные в круглых скобках после format.

full_name = "<> <>".format(name, surname)

5. Удаление пропусков в Python.

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

Python может искать лишние пропуски у правого и левого края строки, так же может удалить с обоих концов строки.

>>> language. rstrip ()
' python'
>>> language. lstrip ()
'python '
>>> language. strip ()
'python'
>>> language
' python '

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

>>> language = ' python '
>>> language
' python '
>>> language = language. strip ()
>>> language
'python'

Сначала пропуски удаляются методом strip() и потом записываются в исходную переменную.

6. Комментарии в Python.

В Python признаком комментария является символ "решетка" ( # ). Интерпретатор Python игнорирует все символы, следующие в коде после # до конца строки.

>>> print('Hello Python')
Hello Python
>>> # print('Hello Python')

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