Методы строк python 3: Методы строк | Python
Содержание
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 на newreplace(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)
: в качестве разделителя используется delimetersplit(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 3 #8: методы строк
Как мы уже
неоднократно говорили, в Python строки являются
объектами и у этих объектов есть методы, то есть, функции, выполняющие
определенные действия:
строка.имя_метода(аргументы)
Для примера,
предположим, у нас имеется такая, уже классическая строка:
и мы собираемся
для нее вызвать метод
String.upper()
который
возвращает строку со всеми заглавными буквами. Для этого, пишется сама строка,
ставится точка и записывается имя метода. В конце обязательно ставим круглые
скобки:
Вот по такому
синтаксису вызываются различные методы строк. Причем, сама переменная string продолжает
ссылается на ту же самую неизмененную строку «Hello World!». Как мы с вами
говорили на предыдущем занятии, строки – это неизменяемые объекты, поэтому
метод upper возвращает
новую строку с заглавными буквами, не меняя прежней.
Если бы нам
потребовалось изменить строку, на которую ссылается переменная string, то это можно
сделать так:
В этом случае
переменная станет ссылаться на новый строковый объект с заглавными буквами, а
прежний будет автоматически удален сборщиком мусора (так как на него не будет
никаких внешних ссылок).
Также этот метод
мы можем вызвать непосредственно у строкового литерала:
Так тоже можно
делать.
Ну и раз уж мы
затронули метод upper, который переводит буквы в верхний
регистр, то отметим противоположный ему метод:
String.lower()
который,
наоборот, преобразует все буквы в строчные. Например:
возвращает
строку «hello world!». Соответственно, сама строка здесь остается прежней,
измененным является новый строковый объект, который и возвращает метод lower. По такому
принципу работают все методы при изменении строк. Следующий метод
String.count(sub[,
start[, end]])
возвращает число
повторений подстроки sub в строке String. Два
необязательных аргумента:
-
start – индекс, с
которого начинается поиск;
-
end – индекс,
которым заканчивается поиск.
В самом простом
случае, мы можем для строки
определить число
повторений сочетаний «ra»:
получим значение
2 – именно столько данная подстрока встречается в нашей строке.
Теперь
предположим, что мы хотим начинать поиск с буквы k, имеющей индекс
4.
Тогда метод
следует записать со значением start=4:
и мы получим
значение 1. Далее, укажем третий аргумент – индекс, до которого будет
осуществляться поиск. Предположим, что мы хотим дойти до 10-го индекса и
записываем:
и получаем
значение 0. Почему? Ведь на индексах 9 и 10 как раз идет подстрока «ra»? Но здесь,
также как и в срезах, последний индекс исключается из рассмотрения. То есть, мы
говорим, что нужно дойти до 10-го, не включая его. А вот если запишем 11:
то последнее
включение найдется.
Следующий метод
String.find(sub[,
start[, end]])
возвращает
индекс первого найденного вхождения подстроки sub в строке String. А аргументы start и end работают также
как и в методе count. Например:
вернет 1,
т.к. первое вхождение «br» как раз начинается с индекса 1. Поставим
теперь значение start=2:
и поиск начнется
уже со второго индекса. Получим значение 8 – индекс следующего вхождения
подстроки «br». Если мы
укажем подстроку, которой нет в нашей строке:
то метод find возвращает -1. Третий
аргумент end определяет
индекс до которого осуществляется поиск и работает также как и в методе count.
Метод find ищет первое
вхождение слева-направо. Если требуется делать поиск в обратном направлении:
справа-налево, то для этого используется метод
String.rfind(sub[,
start[, end]])
который во всем
остальном работает аналогично find. Например:
возвратит 8 –
первое вхождение справа.
Наконец, третий
метод, аналогичный find – это:
String.index(sub[,
start[, end]])
Он работает
абсолютно также как find, но с одним отличием: если указанная подстрока sub не находится в
строке String, то метод
приводит к ошибке:
тогда как find возвращает -1.
Спрашивается: зачем нужен такой ущербный метод index? В
действительности такие ошибки можно обрабатывать как исключения и это бывает
полезно для сохранения архитектуры программы: когда неожиданные ситуации
обрабатываются единым образом в блоке исключений. Но, обо всем этом речь пойдет
позже.
Следующий метод
String.replace(old,
new, count=-1)
Выполняет замену
подстрок old на строку new и возвращает
измененную строку. Например, в нашей строке, мы можем заменить все буквы a на o:
на выходе
получим строку «obrokodobro». Или, так:
Используя этот
метод, можно выполнять удаление заданных фрагментов, например, так:
Третий
необязательный аргумент задает максимальное количество замен. Например:
Заменит только
первые две буквы a: «msg.replace(«a», ‘o’, 2)». При значении
-1 количество замен неограниченно.
Следующие методы
позволяют определить: из каких символов состоит наша строка. Например, метод
String.isalpha()
возвращает True, если строка
целиком состоит из букв и False в противном случае. Посмотрим как он
работает:
вернет True, т.к. наша
строка содержит только буквенные символы. А вот для такой строки:
мы получим False, т.к. имеется
символ пробела.
Похожий метод
String.isdigit()
возвращает True, если строка
целиком состоит из цифр и False в противном случае. Например:
т.к. имеется
символ точки, а вот так:
получим значение
True. Такая проверка
полезна, например, перед преобразованием строки в целое число:
dig = input("Введите число: ") if(dig.isdigit()): dig = int(dig) print(dig) else: print("Число введено неверно")
Следующий метод
String.rjust(width[, fillchar = ‘ ‘])
возвращает новую
строку с заданным числом символов width и при
необходимости слева добавляет символы fillchar:
Получаем строку
« abc» с двумя
добавленными слева пробелами. А сама исходная строка как бы прижимается к
правому краю. Или, можно сделать так:
Получим строку «—abc». Причем вторым
аргументом можно писать только один символ. Если записать несколько, то
возникнет ошибка:
Если ширина width будет меньше
длины строки:
то ничего не
изменится. Аналогично работает метод
String.ljust(width[, fillchar = ‘ ‘])
который
возвращает новую строку с заданным числом символов width, но добавляет
символы fillchar уже справа:
Следующий метод
String.split(sep=None,
maxsplit=-1)
возвращает
коллекцию строк, на которые разбивается исходная строка String. Разбивка
осуществляется по указанному сепаратору sep. Например:
"Иванов Иван Иванович".split(" ")
Мы здесь
разбиваем строку по пробелам. Получаем коллекцию из ФИО. Тот же результат будет
и при вызове метода без аргументов, то есть, по умолчанию он разбивает строку
по пробелам:
"Иванов Иван Иванович".split()
А теперь
предположим, перед нами такая задача: получить список цифр, которые записаны
через запятую. Причем, после запятой может быть пробел, а может и не быть.
Программу можно реализовать так:
digs = "1, 2,3, 4,5,6" digs.replace(" ", "").split(",")
мы сначала
убираем все пробелы и для полученной строки вызываем split, получаем
список цифр.
Обратный метод
String.join(список)
возвращает
строку из объединенных элементов списка, между которыми будет разделитель String. Например:
d = digs.replace(" ", "").split(",") ", ".join(d)
получаем строку
«1, 2, 3, 4, 5, 6». Или так, изначально была строка:
fio = "Иванов Иван Иванович"
и мы хотим здесь
вместо пробелов поставить запятые:
fio2 = ",".join(fio.split())
Теперь fio2 ссылается на
строку с запятыми «Иванов,Иван,Иванович».
Следующий метод
String.strip()
удаляет пробелы
и переносы строк в начале и конце строки. Например:
" hello world \n".strip()
возвращает
строку «hello world». Аналогичные
методы:
String.rtrip()
и String.ltrip()
удаляют пробелы
и переносы строк только справа и только слева.
Вот такие методы
строк существуют в Python. Для наглядности ниже они представлены
в таблице:
Название |
Описание |
String.upper() |
Возвращает
|
String.lower() |
Возвращает
|
String.count(sub[, start[, end]]) |
Определяет
|
String.find(sub[, start[, end]]) |
Возвращает
|
String.rfind(sub[,
|
Возвращает
|
String.index(sub[,
|
Возвращает
|
String.replace(old,
|
Заменяет
|
String.isalpha() |
Определяет:
|
String.isdigit() |
Определяет:
|
String.rjust(width[,
|
Расширяет
|
String.ljust(width[,
|
Расширяет
|
String.split(sep=None,
|
Разбивает
|
String.join(список) |
Объединяет
|
String.strip() |
Удаляет
|
String.rstrip() |
Удаляет
|
String.ltrip() |
Удаляет
|
Задания для самоподготовки
1. Написать
программу корректности ввода телефонного номера по шаблону:
x(xxx)xxxxxx
где x – любая цифра от
0 до 9. Данные представлены в виде строки.
2. Написать
программу изменения строки
«2+3+6.7 +
82 + 5.7 +1″
на строку, в
которой все «+» заменены на «-» и удалены все пробелы
3. Написать
программу вывода чисел 0; -100; 5.6; -3 в виде столбца:
0 -100 5.6 -3
в котором все
строки выровнены по правому краю (подсказка: воспользуйтесь методом rjust).
4. В строке «abrakadabra» найдите все
индексы подстроки «ra» и выведите их (индексы) в консоль.
Методы строк в Python
В Python у разных типов данных есть свои методы (функции), специфичные для этого типа данных. И раз уж на прошлом уроке мы начали знакомиться со строками, то никак не пройти и мимо методов строк.
Вызов метода в Python
Для вызова метода, прибавляем точку к переменной, для которой данный метод вызывается, пишем само название метода и передаем в скобочках аргументы.
переменная.метод(аргументы)
Поиск подстроки в строке Python
Для поиска подстроки в строке в Python, есть четыре метода:
- find()
- rfind()
- index()
- rindex()
Метод find() ищет индекс подстроки в строке — возвращает номер позиции символа указанного в аргументах.
>>> s='Найти подстроку'
>>> s.find('и')
4
В случае нескольких символов идущих подряд, Python вернет позицию, с которой начинается полное совпадение.
>>> s.find('под')
6
При обращении к несуществующей подстроке, вернется значение -1.
>>> s.find('ю')
-1
Метод index() тоже ищет подстроку в строке по её индексу, но в случае поиска несуществующей подстроки в отличии от find(), возвращает ошибку ValueError.
Методы rfind() и rindex() ищут подстроку с конца строки — справа.
>>> s.rfind('т')
10
Замена символа в строке
Метод replace() заменяет одни символы на другие, где первым параметром передаем, что заменить. А во втором параметре указываем , на что заменить.
>>> s.replace('ти','**')
'Най** подстроку'
Как удалить символ из строки?
Передадим во втором параметре пустые кавычки.
>>> s.replace('п','')
'Найти одстроку'
Как удалить пробелы в строке?
Первым параметром указываем пробел, а вторым параметром — пустые кавычки.
>>> s.replace(' ','')
'Найтиподстроку'
Разделить строку в Python
По умолчанию метод split() разделяет строку по пробелам и преобразует строку в список. В итоге мы получили список из трех элементов.
>>> h='разбить строку питон'
>>> h.split()
['разбить', 'строку', 'питон']
Разделить строку можно по любому другому символу, для этого передадим нужный символ в параметрах. При этом, сам символ удаляется из списка.
# Пример 1 - разделить по тире "-"
>>> p='питон-1 питон-2'
>>> p.split('-')
['питон', '1 питон', '2']
# Пример 2 - разделить по букве "t"
>>> c='method split in python'
>>> c.split('t')
['me', 'hod spli', ' in py', 'hon']
Объединить строки в Python
Несмотря на то, что метод join() является не строковым методом. Мы все равно его изучим в рамках данного урока. Поскольку join() в Python выполняет противоположную функцию метода split(). Берет элементы списка и преобразует список в строку. Имя переменной, ссылающейся на список строк — единственный передаваемый параметр метода join(). Перед точкой, мы указали разделитель — пустые кавычки.
>>> a=['1', '2', '3', '4', '5']
>>> ''.join(a)
'12345'
# разделитель пробел
>>> ' '.join(a)
'1 2 3 4 5'
# разделитель запятая
>>> ','.join(a)
'1,2,3,4,5'
Метод join() не работает с числовыми данными. Следующая запись приведет к ошибке.
a=[6, 7, 8]
' '.join(a)
Перед использованием метода join(), следует числа привести к строкам.
>>> e=['9', '10']
>>> ' '.join(e)
'9 10'
Верхний регистр строки в Python
Метод upper() приводит все буквы строки к верхнему регистру, не меняя остальных символов.
>>> w='верхний регистр'
>>> w.upper()
'ВЕРХНИЙ РЕГИСТР'
Нижний регистр строки в Python
Метод lower() приводит все буквы строки к нижнему регистру.
>>> r='НИЖНИЙ РЕГИСТР'
>>> r.lower()
'нижний регистр'
Подсчет количества символов
Метод count() считает, сколько раз встречается подстрока в строке, указанная в параметрах.
>>> y="посчитать количество слов"
>>> y.count('о')
3
Проверка символов в строке
Метод isalpha() проверяет, состоит ли строка только из букв и возвращает истину или ложь.
>>> i='толькобуквы'
>>> i.isalpha()
True
Метод isdigit() проверяет, состоит ли строка только из цифр и возвращает истину или ложь.
>>> f='23456hbbn'
>>> f.isdigit()
False
Создано 30.10.2019 10:53:26
Михаил Русаков
Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!
Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.
Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления
Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.
Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):
Python: поиск подстроки, операции со строками. Как выполнять поиск в строке Python?
В этой статье поговорим про строки в Python, особенности поиска, а также о том, как искать подстроку или символ в строке. Но сначала давайте вспомним основные методы для обработки строк в Python:
• isalpha(str): если строка в Python включает в себя лишь алфавитные символы, возвращается True;
• islower(str): True возвращается, если строка включает лишь символы в нижнем регистре;
• isupper(str): True, если символы строки в Python находятся в верхнем регистре;
• startswith(str): True, когда строка начинается с подстроки str;
• isdigit(str): True, когда каждый символ строки — цифра;
• endswith(str): True, когда строка в Python заканчивается на подстроку str;
• upper(): строка переводится в верхний регистр;
• lower(): строка переводится в нижний регистр;
• title(): для перевода начальных символов всех слов в строке в верхний регистр;
• capitalize(): для перевода первой буквы самого первого слова строки в верхний регистр;
• lstrip(): из строки в Python удаляются начальные пробелы;
• rstrip(): из строки в Python удаляются конечные пробелы;
• strip(): из строки в Python удаляются и начальные, и конечные пробелы;
• rjust(width): когда длина строки меньше, чем параметр width, слева добавляются пробелы, строка выравнивается по правому краю;
• ljust(width): когда длина строки в Python меньше, чем параметр width, справа от неё добавляются пробелы для дополнения значения width, при этом происходит выравнивание строки по левому краю;
• find(str[, start [, end]): происходит возвращение индекса подстроки в строку в Python. В том случае, если подстрока не найдена, выполняется возвращение числа -1;
• center(width): когда длина строки в Python меньше, чем параметр width, слева и справа добавляются пробелы (равномерно) для дополнения значения width, причём происходит выравнивание строки по центру;
• split([delimeter[, num]]): строку в Python разбиваем на подстроки в зависимости от разделителя;
• replace(old, new[, num]): в строке одна подстрока меняется на другую;
• join(strs): строки объединяются в одну строку, между ними вставляется определённый разделитель.
Обрабатываем строку в Python
Представим, что ожидается ввод числа с клавиатуры. Перед преобразованием введенной нами строки в число можно легко проверить, введено ли действительно число. Если это так, выполнится операция преобразования. Для обработки строки используем такой метод в Python, как isnumeric():
string = input("Введите какое-нибудь число: ") if string.isnumeric(): number = int(string) print(number)Следующий пример позволяет удалять пробелы в конце и начале строки:
string = " привет мир! " string = string.strip() print(string) # привет мир!Так можно дополнить строку пробелами и выполнить выравнивание:
print("iPhone 7:", "52000".rjust(10)) print("Huawei P10:", "36000".rjust(10))В консоли Python будет выведено следующее:
iPhone 7: 52000 Huawei P10: 36000Поиск подстроки в строке
Чтобы в Python выполнить поиск в строке, используют метод find(). Он имеет три формы и возвращает индекс 1-го вхождения подстроки в строку:
• 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 # ищем с десятого индекса index = welcome.find("wor",10) print(index) # 21 # ищем с 10-го по 15-й индекс index = welcome.find("wor",10,15) print(index) # -1Замена в строке
Чтобы в Python заменить в строке одну подстроку на другую, применяют метод replace():
• replace(old, new): подстрока old заменяется на new;
• replace(old, new, num): параметр num показывает, сколько вхождений подстроки old требуется заменить на new.Пример замены в строке в Python:
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Разделение на подстроки в Python
Для разделения в Python используется метод split(). В зависимости от разделителя он разбивает строку на перечень подстрок. В роли разделителя в данном случае может быть любой символ либо последовательность символов. Этот метод имеет следующие формы:
• split(): в роли разделителя применяется такой символ, как пробел;
• split(delimeter): в роли разделителя применяется delimeter;
• split(delimeter, num): параметром num указывается, какое количество вхождений delimeter применяется для разделения. При этом оставшаяся часть строки добавляется в перечень без разделения на подстроки.Соединение строк в Python
Рассматривая простейшие операции со строками, мы увидели, как объединяются строки через операцию сложения. Однако есть и другая возможность для соединения строк — метод 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
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(old, new[, num]) | Заменяет в строке S одну подстроку (old) на другую (new) num раз. Если num не указано, то заменить все вхождения old на new. Если num = 1, то заменить первое вхождение old на new. Если num = 3 — заменить первые 3 вхождения old на new. |
S.split([delimeter[, num]]) | разбивает строку на подстроки в зависимости от разделителя |
S.join(список) | объединяет строки в одну строку, вставляя между ними определенный разделитель S |
S.isdigit() | возвращает True, если все символы строки — цифры |
S.isnumeric() | возвращает True, если строка представляет собой число |
S.isalpha() | возвращает True, если строка состоит только из алфавитных символов |
S.isalnum() | Состоит ли строка из цифр или букв |
S.islower() | возвращает True, если строка состоит только из символов в нижнем регистре. Знаки препинания и цифры дают True. |
| возвращает True, если все символы строки в верхнем регистре. Знаки препинания и цифры дают True. |
S.isspace() | Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы (‘\f’), «новая строка» (‘\n’), «перевод каретки» (‘\r’), «горизонтальная табуляция» (‘\t’) и «вертикальная табуляция» (‘\v’)) |
S.istitle() | Возвращает True, если ВСЕ слова в строке начинаются с заглавной буквы |
S.startswith(str) | Возвращает True, если строка начинается с подстроки str |
S.endswith(str) | Возвращает True, если строка заканчивается на подстроку str |
S.capitalize() | Переводит первый символ строки в верхний регистр,
а все остальные в нижний |
S.upper() | переводит строку в вехний регистр |
S.lower() | переводит строку в нижний регистр |
S.title() | начальные символы всех слов в строке переводятся в верхний регистр |
ord(символ) | Символ в его код ASCII |
chr(число) | Код ASCII в символ |
S.center(width, [fill]) | если длина строки меньше параметра width,
то слева и справа от строки равномерно добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по центру |
S.count(str, [start],[end]) | Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию) |
S.expandtabs([tabsize]) | Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам |
S.lstrip([chars]) | удаляет начальные пробелы из строки |
S.rstrip([chars]) | удаляет конечные пробелы из строки |
S.strip([chars]) | удаляет начальные и конечные пробелы из строки
(удаление пробельных символов в начале и в конце строки). В параметре chars можно перечислить символы в любом порядке, которые следует удалить — удаляется символ, который присутствует в chars. |
S.partition(шаблон) | Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки |
S.rpartition(sep) | Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку |
S.swapcase() | Переводит символы нижнего регистра в верхний, а верхнего — в нижний |
S.title() | Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний |
S.zfill(width) | Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями |
S.ljust(width, fillchar=" ") | если длина строки меньше параметра width,
то справа от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по левому краю |
S.rjust(width, fillchar=" ") | если длина строки меньше параметра width,
то слева от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по правому краю |
S.format(*args, **kwargs) | Форматирование строки |
Строковые методы | Кодкамп
Введение
Примеры
Изменение заглавной буквы строки
Тип строки Python предоставляет множество функций, которые влияют на использование заглавных букв в строке. Они включают :
str.casefold
str.upper
str.lower
str.capitalize
str.title
str.swapcase
С юникод строк (по умолчанию в Python 3), эти операции не являются 1: 1 отображения или обратимым. Большинство из этих операций предназначены для отображения, а не нормализации. str.casefold()
str.casefold
создает строчную строку, которая подходит для случая нечувствительных сравнений. Это более агрессивный , чем str.lower
и может изменить строки, которые уже находятся в нижнем регистре или вызывают строки , чтобы расти в длину, и не предназначена для отображения.
"XßΣ".casefold()
# 'xssσ'
"XßΣ".lower()
# 'xßς'
Преобразования, которые происходят в рамках casefolding, определяются Консорциумом Unicode в файле CaseFolding.txt на их веб-сайте. str.upper()
str.upper
принимает каждый символ в строке и преобразует его в верхнем регистре эквивалента, например:
"This is a 'string'.".upper()
# "THIS IS A 'STRING'."
str.lower()
str.lower
делает обратное; он берет каждый символ в строке и преобразует его в строчный эквивалент:
"This IS a 'string'.".lower()
# "this is a 'string'."
str.capitalize()
str.capitalize
возвращает заглавную версию строки, то есть, он делает первый символ имеет верхний регистр , а остальные нижние:
"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."
str.title()
str.title
возвращает название обсаженной версии строки, то есть, каждая буква в начале слова производится в верхнем регистре , а все остальные сделаны в нижнем регистре:
"this Is a 'String'".title()
# "This Is A 'String'"
str.swapcase()
str.swapcase
возвращает новый объект строки , в которой все строчные символы поменяны местами в верхний регистр и все символы верхнего регистра в нижний:
"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"
Использование в качестве str
методов класса
Следует отметить , что эти методы могут быть названы либо на струнных объектов (как показано выше) или как метод класса от str
класса (с явным вызовом str.upper
и т.д.)
str.upper("This is a 'string'")
# "THIS IS A 'STRING'"
Это особенно полезно при применении одного из этих методов для многих строк сразу, скажем, на map
функции.
map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]
Разбить строку на основе разделителя на список строк
str.split(sep=None, maxsplit=-1)
str.split
принимает строку и возвращает список подстрок исходной строки. Поведение отличается в зависимости от того sep
предусмотрен или опущен аргумент.
Если sep
не предусмотрен, или нет None
, то происходит расщепление везде , где есть пробела. Однако начальные и конечные пробелы игнорируются, и несколько последовательных пробельных символов обрабатываются так же, как один пробельный символ:
>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']
>>> " This is a sentence. ".split()
['This', 'is', 'a', 'sentence.']
>>> " ".split()
[]
sep
параметр может быть использован для определения строки разделителей. Исходная строка разделяется там, где встречается строка-разделитель, а сам разделитель отбрасывается. Несколько последовательных разделители не обрабатываются так же , как однократный, а вызвать пустые строки , которые будут созданы.
>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']
>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']
>>> " This is a sentence. ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']
>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']
>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']
По умолчанию заключается в разделении на каждом появлении разделителя, однако maxsplit
параметр ограничивает количество расщеплений , которые происходят. Значение по умолчанию -1
означает , что нет предела:
>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']
>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']
>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']
>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']
str.rsplit(sep=None, maxsplit=-1)
str.rsplit
( «правый раскол») отличается от str.split
( «левый сплит») , когда maxsplit
указано. Расщепление начинается в конце строки, а не в начале:
>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']
>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']
Примечание: Python определяет максимальное число разделений , выполняемых, в то время как большинство других языков программирования указать максимальное количество подстрок созданных. Это может создать путаницу при переносе или сравнении кода.
Заменить все вхождения одной подстроки другой подстрокой
Пайтона str
типа также есть метод для замены вхождений одной подстроки с другой подстроки в заданной строке. Для более сложных случаев можно использовать re.sub
. str.replace(old, new[, count])
:
str.replace
принимает два аргумента , old
и new
, содержащий old
подстроку , которая должна быть заменена на new
подстроку. Необязательный аргумент count
определяет число замен , чтобы быть:
Например, для того , чтобы заменить 'foo'
с 'spam'
в следующей строке, мы можем назвать str.replace
с old = 'foo'
и new = 'spam'
:
>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."
Если данная строка содержит несколько примеров , которые соответствуют old
аргументу, все вхождения заменяются значением подаваемого в new
:
>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."
если, конечно, мы не поставляем значение для count
. В этом случае count
вхождения собираются заменяются:
>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'
str.format и f-strings: форматировать значения в строку
Python обеспечивает интерполяцию строки и функциональность форматирования через str.format
функции, введенной в версии 2.6 и F-строк , введенных в версии 3.6.
Даны следующие переменные:
i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}
Следующие утверждения все эквивалентны
"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"
>>> "{} {} {} {} {}".format(i, f, s, l, d)
>>> str.format("{} {} {} {} {}", i, f, s, l, d)
>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)
>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)
>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)
>>> f"{i} {f} {s} {l} {d}"
>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"
Для справки, Python также поддерживает классификаторы в стиле C для форматирования строк. Примеры , приведенные ниже, эквивалентны тем , которые выше, но str.format
вариантов являются предпочтительными из — за преимущества в гибкости, последовательности обозначений и расширяемости:
"%d %0.1f %s %r %r" % (i, f, s, l, d)
"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)
Скобки используются для интерполяции в str.format
также может быть пронумерована для уменьшения дублирования при форматировании строк. Например, следующее эквивалентно:
"I am from Australia. I love cupcakes from Australia!"
>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")
>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")
В то время как официальная документация питона, как обычно, достаточно тщательно, pyformat.info имеет большой набор примеров с подробными объяснениями.
Кроме того, {
и }
символы могут быть экранированы с помощью двойных скобок:
"{'a': 5, 'b': 6}"
>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)
>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"
См Строка форматирования для получения дополнительной информации. str.format()
был предложен в PEP 3101 и F-строк в PEP 498 .
Подсчет количества появлений подстроки в строке
Один метод доступен для подсчета количества вхождений подстроки в другой строки, str.count
. str.count(sub[, start[, end]])
str.count
возвращает int
, указывающее количество неперекрывающихся вхождений подстрок sub
в другой строке. Необязательные аргументы start
и end
указывают на начало и конец , в котором поиск будет происходить. По умолчанию start = 0
и end = len(str)
означает всю строку будет искать:
>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1
Задавая различные значения для start
, end
, мы можем получить более локализованный поиск и сосчитать, например, если start
равно 13
призыва к:
>>> s.count("sea", start)
1
эквивалентно:
>>> t = s[start:]
>>> t.count("sea")
1
Проверьте начальный и конечный символы строки
Для того , чтобы проверить начало и окончание данной строки в Python, можно использовать методы str.startswith()
и str.endswith()
. str.startswith(prefix[, start[, end]])
Как следует это имя, str.startswith
используется для проверки , начинается ли заданная строка с заданными символами в prefix
.
>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")
False
Необязательные аргументы start
и end
указать начальную и конечную точки , из которых тестирование будет начать и закончить. В следующем примере, указав начальное значение 2
наша строка будет просматриваться с позиции 2
, а затем:
>>> s.startswith("is", 2)
True
Это дает True
, так как s[2] == 'i'
и s[3] == 's'
.
Вы можете также использовать tuple
, чтобы проверить , если он начинается с какой — либо из набора строк
>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False
str.endswith(prefix[, start[, end]])
str.endswith
точно похож на str.startswith
с той лишь разницей, что он ищет окончание символов и не начиная символов. Например, чтобы проверить, заканчивается ли строка полной остановкой, можно написать:
>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False
как и с startswith
более одного символа может использоваться как окончание последовательности:
>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False
Вы можете также использовать tuple
, чтобы проверить , если он заканчивается любой из набора строк
>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False
Проверка того, из чего состоит строка
Пайтона str
тип также имеет целый ряд методов , которые могут быть использованы для оценки содержимого строки. Это str.isalpha
, str.isdigit
, str.isalnum
, str.isspace
. Капитализация может быть проверена с str.isupper
, str.islower
и str.istitle
. str.isalpha
str.isalpha
не принимает никаких аргументов и возвращает True
, если все символы в данной строке являются буквенными, например:
>>> "Hello World".isalpha() # contains a space
False
>>> "Hello2World".isalpha() # contains a number
False
>>> "HelloWorld!".isalpha() # contains punctuation
False
>>> "HelloWorld".isalpha()
True
В краевой случае пустая строка вычисляет значение False
при использовании "".isalpha()
. str.isupper
, str.islower
, str.istitle
Эти методы проверяют использование заглавных букв в заданной строке.
str.isupper
это метод , который возвращает True
, если все символы в данной строке в верхнем регистре и False
иначе.
>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False
С другой стороны , str.islower
это метод , который возвращает True
, если все символы в данной строке в нижнем регистре и False
иначе.
>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False
str.istitle
возвращает True
, если данная строка названия обсаженное; то есть каждое слово начинается с заглавной буквы, за которой следуют строчные буквы.
>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False
str.isdecimal
, str.isdigit
, str.isnumeric
str.isdecimal
возвращает строка , является ли последовательность десятичных цифр, пригодная для представления десятичного числа.
str.isdigit
включает в себя цифру не в форме , подходящей для представления десятичного числа, такие , как надстрочные цифры.
str.isnumeric
включает в себя любые числовые значения, даже если не цифры, такие как значения вне диапазона 0-9.
isdecimal isdigit isnumeric
12345 True True True
១2߃໔5 True True True
①²³🄅₅ False True True
⑩⒓ False False True
Five False False False
Байтовые строки ( bytes
в Python 3, str
в Python 2), поддерживает только isdigit
, который проверяет только основные ASCII цифр.
Как str.isalpha
пустая строка вычисляет значение False
. str.isalnum
Это сочетание str.isalpha
и str.isnumeric
, в частности , он имеет значение True
, если все символы в данной строке являются буквенно — цифровыми, то есть они состоят из буквенных или цифровых символов:
>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum() # contains whitespace
False
str.isspace
Возвращает True
, если строка содержит только пробельные символы.
>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True
Иногда строка выглядит «пустой», но мы не знаем, так ли это, потому что она содержит только пробелы или вообще не содержит символов
>>> "".isspace()
False
Чтобы покрыть этот случай нам нужен дополнительный тест
>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True
Но самый короткий путь , чтобы проверить , если строка пуста или содержит только пробельные символы, чтобы использовать strip
(без аргументов она удаляет все начальные и конечные пробельные символы)
>>> not my_str.strip()
True
str.translate: перевод символов в строке
Python поддерживает translate
метод на str
типа , который позволяет указать таблицу преобразования (используется для замены), а также любые символы , которые должны быть удалены в процессе.
str.translate(table[, deletechars])
параметр Описание table
Это таблица поиска, которая определяет отображение от одного символа к другому. deletechars
Список символов, которые должны быть удалены из строки.
maketrans
метод ( str.maketrans
в Python 3 и string.maketrans
в Python 2) позволяет создать таблицу перевода.
>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th4s 3s 1 str3ng!'
translate
метод возвращает строку , которая является переведенной копией исходной строки.
Вы можете установить table
аргумент None
, если требуется только для удаления символов.
>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'
Удаление нежелательных начальных / конечных символов из строки
Три метода при условии , что предлагают возможность раздеться начальные и конечные символы из строки: str.strip
, str.rstrip
и str.lstrip
. Все три метода имеют одинаковую подпись, и все три возвращают новый строковый объект с удаленными нежелательными символами. str.strip([chars])
str.strip
действует на заданной строки и удаляет (полоски) или каких — либо ведущих задних символов , содержащихся в аргументе chars
; если chars
не входит в комплект или нет None
, все пробельные символы удаляются по умолчанию. Например:
>>> " a line with leading and trailing space ".strip()
'a line with leading and trailing space'
Если chars
поставляются, все символы , содержащиеся в нем, удаляются из строки, которая возвращается. Например:
>>> ">>> a Python prompt".strip('> ') # strips '>' character and space character
'a Python prompt'
str.rstrip([chars])
и str.lstrip([chars])
Эти методы имеют ту же семантику и аргументы с str.strip()
, их отличие заключается в том направлении , откуда они начинаются. str.rstrip()
начинается с конца строки в то время как str.lstrip()
расщепляется с начала строки.
Например, при использовании str.rstrip
:
>>> " spacious string ".rstrip()
' spacious string'
В то время как, используя str.lstrip
:
>>> " spacious string ".rstrip()
'spacious string '
Сравнение строк без учета регистра
Сравнение строки без учета регистра кажется чем-то тривиальным, но это не так. В этом разделе рассматриваются только строки Unicode (по умолчанию в Python 3). Обратите внимание, что Python 2 может иметь незначительные недостатки по сравнению с Python 3 — более поздняя обработка юникода гораздо более полная.
Первое, на что следует обратить внимание, это то, что преобразования с удалением регистра в юникоде не являются тривиальными. Существует текст , для которого text.lower() != text.upper().lower()
, Например, "ß"
:
>>> "ß".lower()
'ß'
>>> "ß".upper().lower()
'ss'
Но предположим, что вы хотели регистронезависмо сравнивать "BUSSE"
и "Buße"
. Черт возьми, вы , вероятно , также хотят , чтобы сравнить "BUSSE"
и "BUẞE"
равный — это новая форма капитала. Рекомендуемый способ заключается в использовании casefold
:
>>> help(str.casefold)
"""
Help on method_descriptor:
casefold(...)
S.casefold() -> str
Return a version of S suitable for caseless comparisons.
"""
Не просто использовать lower
. Если casefold
не доступен, делая .upper().lower()
помогает (но только немного).
Тогда вы должны рассмотреть акценты. Если визуализатор шрифт хорошо, вы , вероятно , думаете , "ê" == "ê"
— но это не так :
>>> "ê" == "ê"
False
Это потому что они на самом деле
>>> import unicodedata
>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']
>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']
Самый простой способ справиться с этим unicodedata.normalize
. Вы , вероятно , хотите использовать NFKD нормализации, но не стесняйтесь проверить документацию. Тогда один
>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True
Чтобы закончить, здесь это выражается в функциях:
import unicodedata
def normalize_caseless(text):
return unicodedata.normalize("NFKD", text.casefold())
def caseless_equal(left, right):
return normalize_caseless(left) == normalize_caseless(right)
Объединить список строк в одну строку
Строка может быть использована в качестве разделителя , чтобы присоединиться к списку строк вместе в одну строку с помощью join()
метод. Например, вы можете создать строку, где каждый элемент в списке разделен пробелом.
>>> " ".join(["once","upon","a","time"])
"once upon a time"
В следующем примере строковые элементы разделяются тремя дефисами.
>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"
Полезные константы строкового модуля
Пайтона string
модуль предоставляет константы для операций , связанных строк. Для того, чтобы использовать их, импортировать string
модуля:
>>> import string
string.ascii_letters
:
Стечение ascii_lowercase
и ascii_uppercase
:
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.ascii_lowercase
:
Содержит все символы нижнего регистра ASCII:
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
string.ascii_uppercase
:
Содержит все символы ASCII в верхнем регистре:
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.digits
:
Содержит все десятичные цифры:
>>> string.digits
'0123456789'
string.hexdigits
:
Содержит все шестнадцатеричные символы:
>>> string.hexdigits
'0123456789abcdefABCDEF'
string.octaldigits
:
Содержит все восьмеричные символы:
>>> string.octaldigits
'01234567'
string.punctuation
:
Содержит все символы , которые считаются знаки препинания в C
локали:
>>> string._`{|}~ \t\n\r\x0b\x0c'
Сторнирование строки
Строка может реверсировать с использованием встроенных в reversed()
функции, которая принимает строку и возвращает итератор в обратном порядке.
>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']
reversed()
могут быть обернуты в вызове ''.join()
, чтобы сделать строку из итератора.
>>> ''.join(reversed('hello'))
'olleh'
В то время как с использованием reversed()
может быть более удобными для чтения для непосвященных пользователей Python, используя расширенную нарезку с шагом -1
быстрее и более кратким. Вот, попробуйте реализовать это как функцию:
>>> def reversed_string(main_string):
... return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'
Обоснуйте строки
Python предоставляет функции для выравнивания строк, позволяя заполнять текст, чтобы упростить выравнивание различных строк.
Ниже приведен пример str.ljust
и str.rjust
:
interstates_lengths = {
5: (1381, 2222),
19: (63, 102),
40: (2555, 4112),
93: (189,305),
}
for road, length in interstates_lengths.items():
miles,kms = length
print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))
40 -> 2555 миль (4112 км.) 19 -> 63 миль. (102 км.) 5 -> 1381 миль. (2222 км.) 93 -> 189 миль. (305 км.)
ljust
и rjust
очень похожи. Оба имеют width
параметр и необязательный fillchar
параметр. Любая строка , создаваемая эти функции, по крайней мере до тех пор , как width
параметр , который был передан в функцию. Если строка длиннее , чем width
alread, она не усекается. fillchar
аргумент, который по умолчанию используется символ пробела ' '
должен быть один символ, а не multicharacter строка.
ljust
функция подушечки конца строки она называется на с fillchar
до тех пор, пока width
длиной символов. rjust
функция подушечки начала строки в подобной манере. Таким образом, l
и r
в названиях этих функций относятся к стороне , что исходная строка, а не fillchar
, расположена в выходной строке.
Преобразование между str или байтовыми данными и символами юникода
Содержимое файлов и сетевых сообщений может представлять собой закодированные символы. Их часто нужно преобразовывать в юникод для правильного отображения.
В Python 2 вам может потребоваться преобразовать данные str в символы Unicode. По умолчанию ( ''
, ""
и т.д.) является строкой ASCII, с любыми значениями за пределами диапазона ASCII отображается в виде уцелевших значений. Unicode строки u''
(или u""
и т.д.).
# You get "© abc" encoded in UTF-8 from a file, network, or other data source
s = '\xc2\xa9 abc' # s is a byte array, not a string of characters
# Doesn't know the original was UTF-8
# Default form of string literals in Python 2
s[0] # '\xc2' - meaningless byte (without context such as an encoding)
type(s) # str - even though it's not a useful one w/o having a known encoding
u = s.decode('utf-8') # u'\xa9 abc'
# Now we have a Unicode string, which can be read as UTF-8 and printed properly
# In Python 2, Unicode string literals need a leading u
# str.decode converts a string which may contain escaped bytes to a Unicode string
u[0] # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u) # unicode
u.encode('utf-8') # '\xc2\xa9 abc'
# unicode.encode produces a string with escaped bytes for non-ASCII characters
В Python 3 вам может потребоваться преобразовать массивы байтов (называемые «байтовым литералом») в строки символов Unicode. По умолчанию теперь строка Unicode, и байтовой строки литералов теперь должны быть введены как b''
, b""
, и т.д. Байт буквальным будет возвращать True
в isinstance(some_val, byte)
, предполагая some_val
быть строка , которая может быть закодированы в байтах.
# You get from file or network "© abc" encoded in UTF-8
s = b'\xc2\xa9 abc' # s is a byte array, not characters
# In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0] # b'\xc2' - meaningless byte (without context such as an encoding)
type(s) # bytes - now that byte arrays are explicit, Python can show that.
u = s.decode('utf-8') # '© abc' on a Unicode terminal
# bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0] # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u) # str
# The default string literal in Python 3 is UTF-8 Unicode
u.encode('utf-8') # b'\xc2\xa9 abc'
# str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.
Строка содержит
Python делает его чрезвычайно интуитивным, чтобы проверить, содержит ли строка заданную подстроку. Просто используйте in
операторе:
>>> "foo" in "foo.baz.bar"
True
Примечание: тестирование пустой строки всегда будет приводить True
:
>>> "" in "test"
True
Синтаксис
Параметры
Примечания
Python 3 — Строки
Строки являются одними из самых популярных типов в Python. Мы можем создать их, просто заключив символы в кавычках. Python рассматривает одиночные кавычки так же, как и двойные кавычки. Создание строк так же просто, как и присвоение значения переменной. Например:
var1 = 'Привет мир!' var2 = "программирование на Python"
Доступ к значениям в строках
Python не поддерживает тип символов; они рассматриваются как строки одной длины, таким образом, также считается подстроки.
Чтобы получить доступ к подстроке, используйте квадратные скобки вместе с индексом или индексами, чтобы получить вашу подстроку. Например:
#!/usr/bin/python3 var1 = 'Привет мир!' var2 = "программирование на Python" print ("var1[0]: ", var1[0]) print ("var2[1:5]: ", var2[1:5])
Когда код выполниться, он покажет следующий результат:
var1[0]: П var2[1:5]: ytho
Обновление строк
Вы можете «обновить» существующую строку c присваиванием переменной на другую строку. Новое значение может быть связано с его предыдущим значением или совершенно другой строкой. Например:
#!/usr/bin/python3 var1 = 'Привет мир!' print ("Обновление строки :- ", var1[:6] + 'Python')
Когда код выполниться, получиться следующий результат:
Обновление строки :- Hello Python
Символ Escape
В следующей таблице приведен список escape или непечатаемых символов, которые могут быть представлены с представлением.
Символ escape интерпретируется: в одинарных кавычках, а также в двойных кавычках.
Представление | Шестнадцатеричный символ | Описание |
---|---|---|
\a | 0x07 | Звонок или оповещение |
\b | 0x08 | Backspace |
\cx | Control-х | |
\C-x | Control-х | |
\e | 0x1b | Escape |
\f | 0x0C | Formfeed |
\M- \C-x | Meta-Control-x | |
\n | 0x0a | Новая линия |
\nnn | Восьмеричная запись, где п находится в диапазоне от 0,7 | |
\r | 0x0d | Возврат каретки |
\s | 0x20 | Пробел |
\t | 0x09 | Табуляция |
\v | 0x0B | Вертикальная табуляция |
\x | Символ х | |
\xnn | Шестнадцатеричное, где n находится в диапазоне от 0,9, a.f, или A.F |
Специальные строковые операторы
Предположим, переменная строка а, имеет «Hello» а переменная b равна «Python», тогда:
оператор | Описание | пример |
---|---|---|
+ | Конкатенация – Добавляет значения по обе стороны от оператора | A + B = HelloPython |
* | Повторение – Создает новые строки, объединяя нескольких копий одной и той же строки | а * 2 = HelloHello |
[] | Кусочек – Выдает символ из данного индекса | а [1] = е |
[ : ] | Диапазон среза – Дает символы из заданного диапазона | а [1: 4] = ELL |
in | Возвращает истину, если символ существует в данной строке | Н = 1 |
not in | Возвращает истину, если символ не существует в данной строке | М <> 1 |
r/R | Raw String – Подавляет фактическое значение символов Escape. Синтаксис для необработанных строк точно такой же, как и для обычных строк, за исключением raw строки оператора, буква «r», которая предшествует кавычки. «R» может быть в нижнем регистре (r) или в верхнем регистре (R) и должна быть размещена непосредственно предшествующей первой кавычки. | print r’\n’ печатает \n и print R’\n’печатает \n |
% | Формат – Выполняет форматирование строк | См в следующем разделе |
Оператор форматирования строки
Одна из самых привлекательных особенностей языка Python является оператор форматирования строк %. Этот оператор является уникальным для строк и блоков, имеющие функции из языка C printf(). Ниже приведен простой пример:
#!/usr/bin/python3 print ("Меня зовут %s и мой вес равен %d кг!" % ('AndreyEx', 71))
Когда код выполниться, будет показан следующий результат:
Меня зовут AndreyEx и мой вес равен 71 кг!
Вот полный набор списка символов, которые могут быть использованы вместе с %:
S.No. | Формат символов и преобразование |
---|---|
1 | %c символ |
2 | %s преобразование строки с помощью str() до форматирования |
3 | %i десятичное число |
4 | %d десятичное число |
5 | %u беззнаковое десятичное целое |
6 | %o восьмеричное целое |
7 | %x шестнадцатеричное число (прописные буквы) |
8 | %X шестнадцатеричное число (заглавные буквы) |
9 | %e экспоненциальное (с строчной «х») |
10 | %E экспоненциальное (с «E» в верхнем регистре) |
11 | %f вещественное число с плавающей точкой |
12 | %g наименьшее из %f и %е |
13 | %G наименьшее из% F% и E |
Другие поддерживаемые символы и функции перечислены в следующей таблице:
S.No. | Символ и функциональность |
---|---|
1 | * аргумент определяет ширину или точность |
2 | – выравнивание по левому краю |
3 | + отобразить знак |
4 | <sp> поставить пробел перед положительным числом |
5 | # добавить восьмеричной ведущий ноль ( «0») или шестнадцатеричным ведущий «0x» или «0X», в зависимости от того, был использован «х» или «X». |
6 | 0 заместить слева нулями (вместо пробелов) |
7 | «%%» оставляет вас с одним буквальным «%» |
8 | (var) соотнесение переменных (словарные аргументы) |
9 | m.n. минимальная общая ширина и n число цифр, отображаемых после десятичной точки (если заявл.) |
Тройные кавычки
Тройные кавычки в Python приходят на помощь, позволяя строкам занимать несколько строк, в том числе стенографические символы новой строки, табуляции, а также любые другие специальные символы.
Синтаксис для тройных кавычек состоит из трех последовательных одиночных или двойных кавычек.
#!/usr/bin/python3 para_str = """это длинная строка, которая состоит из несколько строк и непечатаемых символов, таких как TAB ( \t ) и они показывают тот путь, когда отображается. Символы новой строки в строке, прямо как в скобках [ \n ], или просто новую строку с присваиванием переменной также будет отображаться. """ print (para_str)
Когда приведенный выше код выполнится, он произведет следующий результат. Обратите внимание, что каждый специальный символ был преобразован в печатный вид, вплоть до последней новой строки в конце строки между «вверх». и закрытие тройные кавычки. Также отметим, что новая строка происходит либо с явным возвратом каретки в конце строки либо escape кодом (\n):
это длинная строка, которая состоит из несколько строк и непечатаемых символов, таких как TAB ( ) и они показывают тот путь, когда отображается. Символы новой строки в строке, прямо как в скобках [ ], или просто новую строку с присваиванием переменной также будет отображаться.
Неочищенные строки не относятся к обратной косой черты как к специальному символу. Каждый символ, который вы поместили в строку остается так, как вы его написали:
#!/usr/bin/python3 print ('C:\\nowhere')
Когда код выполниться, он выдаст следующий результат:
C:\nowhere
Теперь давайте используем строку. Мы укажем выражение следующим образом:
#!/usr/bin/python3 print (r'C:\\nowhere')
Когда код выполниться, он выдаст следующий результат:
C:\\nowhere
Строки Юникода
В Python 3 все строки представлены в Unicode. В Python 2 хранятся в виде 8-битного ASCII, следовательно, требуется указать «u», чтобы сделать его Unicode. Больше нет необходимости в настоящее время.
Встроенные методы строк
Python включает в себя следующие встроенные методы манипулирования строками:
S.No. | Методы и описание |
---|---|
1 | capitalize() – Прописная первая буква строки |
2 | center(width, fillchar) – Возвращает строку, заполненную с FillChar от исходной строки с центром в общем столбце width. |
3 | count(str, beg = 0,end = len(string)) – Считает, сколько раз str имеет вхождение в строке или в подстроках строки, начиная с индекса str и заканчивается индексом end. |
4 | decode(encoding = ‘UTF-8’,errors = ‘strict’) – Декодирует строку, используя кодек, зарегистрированный для кодирования. кодирования по умолчанию строки по умолчанию кодировке. |
5 | encode(encoding = ‘UTF-8’,errors = ‘strict’) – Возвращает закодированные строки версии строки; при ошибке, по умолчанию вызывает исключение ValueError, если ошибки не указываются с ‘ignore’ or ‘replace’. |
6 | endswith(suffix, beg = 0, end = len(string)) – Определяет, является ли строка или подстроку строки (если начальный индекс нач и заканчивая концом индекса приведены) заканчивается суффиксом; возвращает истину, если так и ложь в противном случае. |
7 | expandtabs(tabsize = 8) – Расширяет вкладки в строке на несколько пробелов; по умолчанию 8 пространств на вкладке, если TabSize не предусмотрено. |
8 | find(str, beg = 0 end = len(string)) – Определить, встречается ли строка в строке или в подстроки строки, если начинается с индекса beg и заканчивается индексом end, индекс возвращается, если найден и -1 в противном случае. |
9 | index(str, beg = 0, end = len(string)) – То же действие, что find(), но вызывает исключение, если строка не найдена. |
10 | isalnum() – Возвращает истину, если строка имеет по крайней мере 1 символ и все символы являются алфавитно-цифровыми и ложью в противном случае. |
11 | isalpha() – Возвращает истину, если строка имеет по крайней мере 1 символ и все символы буквенные и ложь в противном случае. |
12 | isdigit() – Возвращает истину, если строка содержит только цифры и ложь в противном случае. |
13 | islower() – Возвращает истину, если строка имеет по крайней мере 1 символ в нижнем регистре и все символы в нижнем регистре и ложь в противном случае. |
14 | isnumeric() – Возвращает истину, если строка Юникода содержит только числовые символы и ложь в противном случае. |
15 | isspace() – Возвращает истину, если строка содержит только символы пробелов и ложь в противном случае. |
16 | istitle() – Возвращает истину, если строка имеет«titlecased» и ложь в противном случае. |
17 | isupper() – Возвращает истину, если строка имеет по крайней мере один символ в верхнем регистре или все символы в верхнем регистре и ложь в противном случае. |
18 | join(seq) – Слияния (Объединяет) строковых элементов в последовательности seq в строку со строкой разделителя. |
19 | len(string) – Возвращает длину строки |
20 | ljust(width[, fillchar]) – Возвращает space-padded строку в исходную строку с выравниванием влево на итоговую ширину столбцов. |
21 | lower() – Преобразует все прописные буквы в строке в нижний регистр. |
22 | lstrip() – Удаляет начальные пробелы в строке. |
23 | maketrans() – Возвращает таблицу перевода для использования в функции перевода. |
24 | max(str) – Возвращает максимальный алфавитный символ из строки str. |
25 | min(str) – Возвращает минимальный алфавитный символ из строки str. |
26 | replace(old, new [, max]) – Заменяет все вхождения old в строке на new или в большинстве случаев, если max задано. |
27 | rfind(str, beg = 0,end = len(string)) – То же, что find(), но поиск в обратном направлении в строке. |
28 | rindex( str, beg = 0, end = len(string)) – То же, что index(), но поиск в обратном направлении в строке. |
29 | rjust(width,[, fillchar]) – Возвращает space-padded строку из исходной строки, выравнивается по правому краю в количестве width столбцов. |
30 | rstrip() – Удаляет все конечные пробелы из строки. |
31 | split(str=””, num=string.count(str)) – Разделяет строку в соответствии с разделителем str (пробел, если не предусмотрено) и возвращает список из подстроке; разделяет на num подстроку, если дано. |
32 | splitlines( num=string.count(‘\n’)) – Разбивает строку на все (или числа) строки и возвращает список каждой строки с удаленными символами новой строки. |
33 | startswith(str, beg=0,end=len(string)) – Определяет, является ли строка или подстрока в строке (если начальный индекс нач и заканчивается указанием на конец) начинается с подстроки str; возвращает истину, если так и ложь в противном случае. |
34 | strip([chars]) – Выполняет как lstrip() и rstrip() в строке |
35 | swapcase() – Инверсия для всех букв в строке. |
36 | title() – Возвращает «titlecased» версию строки, то есть, все слова начинаются с верхним регистром, а остальное в нижнем регистре. |
37 | translate(table, deletechars=””) – Переводит строку согласно таблице перевода str(256 символов), убрав deletechars. |
38 | upper() – Преобразование строчных букв в строке в верхний регистр. |
39 | zfill (width) – Возвращает исходную строку добавленную слева с нулями с указанной шириной символов; предназначенный для чисел, zfill() сохраняет любой данный знак (менее один ноль). |
40 | isdecimal() – Возвращает истину, если строка содержит только десятичные знаки и ложь в противном случае. |
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
Метод | Описание | Примеры | ||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
капитализировать () | Возвращает копию строки, в которой первый символ в верхнем регистре, а остальные в нижнем. Используйте | a = «пчелиный укус» Результат Укус пчелы | ||||||||||||||||||||||||
кожух () | Возвращает копию строки в развернутом виде. Строки с регистром могут использоваться для сопоставления без регистра. | a = «BEE» Результат пчела | ||||||||||||||||||||||||
центр ( ширина [, fillchar ]) | Возвращает строку с центром в строке длиной шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s) | a = «пчела» Результат ---- пчела ----- | ||||||||||||||||||||||||
count ( sub [, start [, end ]]) | Возвращает количество неперекрывающихся вхождений подстроки ( подстрока ) в диапазоне [ начало , конец ].Необязательные аргументы начало и конец интерпретируются как в нотации среза. Неперекрывающиеся вхождения означает, что Python не будет дублировать символы, которые уже были подсчитаны. Например, при использовании подстроки | a = «Шашлычный суп» Результат 0 5 2 1 0 2 3 | ||||||||||||||||||||||||
кодировать (encoding = "utf-8", errors = "strict") | Возвращает закодированную версию строки как байтовый объект. Кодировка по умолчанию —
| из base64 импортировать b64encode a = «Банан» a = b64encode (a.кодировать ()) Результат банан b'QmFuYW5h ' | ||||||||||||||||||||||||
заканчивается на ( суффикс [, начало [, конец ]]) | Возвращает | a = «Банан» Результат Верно Правда Ложь Правда | ||||||||||||||||||||||||
expandtabs (tabsize = 8) | Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции.Позиции табуляции появляются для каждого символа табуляции (по умолчанию | а = «1 \ t2 \ t3» Результат 1 2 3 1 2 3 1 2 3 1 2 3 | ||||||||||||||||||||||||
find ( sub [, start [, end ]]) | Возвращает наименьший индекс в строке, где подстрока sub находится в пределах фрагмента Метод | a = «Фитнес» Результат 0 -1 3 3 4 -1 -1 | ||||||||||||||||||||||||
формат (* args , ** kwargs ) | Выполняет операцию форматирования строки.Строка, для которой вызывается этот метод, может содержать буквальный текст или поля замены, разделенные фигурными скобками | # Пример 1 # Пример 2 # Пример 3 # Пример 4 # Пример 5 Результат Чай и кофе Кофе и чай Горох и фасоль 1, 2, 3 Обед: пицца, вино | ||||||||||||||||||||||||
format_map ( отображение ) | Аналогичен формату | # Пример 1 # Пример 2 обед = {«Еда»: «Пицца»} обед = {«Напиток»: «Вино»} Результат Обед: пицца, вино Обед: пицца, напитки Обед: еда, вино | ||||||||||||||||||||||||
индекс ( sub [, начало [, конец ]]) | Подобно | a = «Фитнес» Результат 0 3 3 4 ValueError: подстрока не найдена | ||||||||||||||||||||||||
isalnum () | Возвращает Символ c считается буквенно-цифровым, если одно из следующих значений возвращает
| c = «Фитнес» c = «123» c = «1,23» c = «$ *% !!!» c = «0,34j» Результат Верно Правда Ложь Ложь Ложь | ||||||||||||||||||||||||
isalpha () | Возвращает Обратите внимание, что «алфавитными» в данном случае являются те символы, которые определены в базе данных символов Unicode как «Letter». Это персонажи, общее свойство категории которых может быть одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Это отличается от свойства «Alphabetic», определенного в стандарте Unicode. | c = «Фитнес» c = «123» c = «$ *% !!!» Результат Верно Ложь Ложь | ||||||||||||||||||||||||
десятичное () | Возвращает Десятичные символы — это те, которые могут использоваться для образования чисел с основанием 10. Десятичные символы — это символы из общей категории Unicode «Nd». Вы можете увидеть разницу между | c = «123» c = u «\ u00B2» c = «1,23» c = «u123» c = «Фитнес» c = «$ *% !!!» Результат Верно Ложь Ложь Ложь Ложь Ложь | ||||||||||||||||||||||||
isdigit () | Возвращает Метод Цифра — это символ, имеющий значение свойства Вы можете увидеть разницу между | c = «123» c = u «\ u00B2» c = «1,23» c = «u123» c = «Фитнес» c = «$ *% !!!» Результат Верно Правда Ложь Ложь Ложь Ложь | ||||||||||||||||||||||||
isidentifier () | Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, разделом «Идентификаторы» и ключевыми словами из документации Python. Используйте | а = «123» a = «_user_123» a = «_user-123» a = «Гомер» a = «для» Результат Ложь Правда Ложь Правда Правда | ||||||||||||||||||||||||
нижний () | Возвращает Символы в регистре — это символы, общее свойство категории которых является одним из следующих: «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка). Вы можете использовать | а = «» а = «123» a = «_user_123» a = «Гомер» a = «HOMER» а = «гомер» a = «HOMER» Результат Ложь Ложь Правда Ложь Ложь Правда Правда | ||||||||||||||||||||||||
числовой () | Возвращает Числовые символы включают цифровые символы и все символы, которые имеют свойство числового значения Unicode. Цифровые символы — это символы со значением свойства | c = «123» c = u «\ u00B2» c = «1,23» c = «u123» c = «Фитнес» c = «$ *% !!!» Результат Верно Правда Ложь Ложь Ложь Ложь | ||||||||||||||||||||||||
для печати () | Возвращает Непечатаемые символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», за исключением пробела ASCII ( Печатные символы в этом контексте — это те, которые не следует экранировать при вызове | а = «» а = «» a = u «\ u00B2» a = «Барт» а = «\ т» a = «\ r \ n» a = «Барт \ r» Результат Верно Правда Правда Правда Ложь Ложь Ложь | ||||||||||||||||||||||||
isspace () | Возвращает Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также символы, для которых свойство двунаправленности является одним из «WS», «B» или «S». | а = «» а = «» a = «Барт» а = «\ т» a = «\ r \ n» a = «Барт \ r» Результат Ложь Правда Ложь Правда Правда Ложь | ||||||||||||||||||||||||
название () | Возвращает Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также символы, для которых свойство двунаправленности является одним из «WS», «B» или «S». | а = «» а = «» а = «т» а = «Т» a = «Чай» a = «Чай и кофе» a = «Чай и кофе» a = «1. Чай и кофе \ r» Результат Ложь Ложь Ложь Правда Правда Ложь Правда Правда | ||||||||||||||||||||||||
верхний () | Возвращает Символы в регистре — это символы, общее свойство категории которых является одним из следующих: «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка). | а = «» а = «123» a = «_USER_123» a = «Гомер» a = «HOMER» а = «гомер» a = «HOMER» Результат Ложь Ложь Правда Ложь Правда Ложь Ложь | ||||||||||||||||||||||||
соединение (итерация) | Возвращает строку, которая представляет собой конкатенацию строк в итеративном .Ошибка | а = «-» a = «.» a = «.» Результат 1-2-3 СОЕДИНЕННЫЕ ШТАТЫ АМЕРИКИ Доктор Кто | ||||||||||||||||||||||||
ljust ( ширина [, fillchar ]) | Возвращает строку, выровненную по левому краю, в строке длиной и шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s) | a = «пчела» Результат пчела --------- | ||||||||||||||||||||||||
нижний () | Возвращает копию строки, в которой все символы в регистре преобразованы в нижний регистр. | a = «BEE» Результат пчела | ||||||||||||||||||||||||
lstrip ([ chars ]) | Вернуть копию строки с удаленными ведущими символами.Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение Обратите внимание, что аргумент chars не является префиксом — все комбинации его значений удаляются. | a = «Пчела» a = «—— Пчела ——» Результат Пчела! Пчела ----- | ||||||||||||||||||||||||
maketrans ( x [, y [, z ]]) | Это статический метод, который возвращает таблицу перевода, используемую для
| frm = «SecrtCod» Результат 123425 6782 | ||||||||||||||||||||||||
перегородка ( сен ) | Разбивает строку при первом появлении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки. | a = «Python-программа» print (a.partition («-«)) Результат ('Python', '-', 'программа') ('Программа Python', '', '') | ||||||||||||||||||||||||
заменить ( старый , новый [, count ]) | Возвращает копию строки, в которой все вхождения подстроки старый заменены на новый .Если указан необязательный аргумент count , заменяются только первые count вхождения. Например, если count равно | a = «Чайный пакетик. Чайная чашка. Чайные листья.» print (a.replace («Чай», «Кофе»)) Результат Кофейный пакетик. Кофейная чашка. Листья кофе. Пакетик для кофе. Кофейная чашка. Чайные листья. | ||||||||||||||||||||||||
rfind ( sub [, start [, end ]]) | Возвращает наивысший индекс в строке, в которой найдена подстрока sub , так что sub содержится в пределах | a = «Да, фитнес» print (a.rfind («Y»)) Результат 0 8 10 9 -1 -1 -1 | ||||||||||||||||||||||||
rindex ( sub [, start [, end ]]) | Подобно | a = «Да, фитнес» print (a.rindex («Y»)) Результат 0 8 10 9 ValueError: подстрока не найдена ValueError: подстрока не найдена ValueError: подстрока не найдена | ||||||||||||||||||||||||
rjust ( ширина [, fillchar ]) | Возвращает строку, выровненную по правому краю, в строке длиной и шириной .Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s) | a = «пчела» Результат --------- пчела | ||||||||||||||||||||||||
r раздел ( sep ) | Разбивает строку в последнем вхождении sep и возвращает кортеж из трех частей, содержащий часть перед разделителем, сам разделитель и часть после разделителя.Если разделитель не найден, он возвращает 3-кортеж, содержащий саму строку, за которой следуют две пустые строки. | a = «Гомер-Джей-Симпсон» print (a.rpartition («-«)) Результат ('Гомер-Джей', '-', 'Симпсон') ('', '', 'Гомер-Джей-Симпсон') | ||||||||||||||||||||||||
rsplit (sep = None, maxsplit = -1) | Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано За исключением разделения справа, | a = «Гомер Джей Симпсон» a = «Гомер-Джей-Симпсон» Результат [«Гомер», «Джей», «Симпсон»] [«Гомер-Джей», «Симпсон»] | ||||||||||||||||||||||||
rstrip ([ chars ]) | Вернуть копию строки с удаленными завершающими символами. Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение Обратите внимание, что аргумент chars не является суффиксом — все комбинации его значений удаляются. | a = «Пчела» a = «—— Пчела ——» Результат Пчела! ----- Пчела | ||||||||||||||||||||||||
разделить (sep = None, maxsplit = -1) | Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано Если задано sep , последовательные разделители не группируются вместе и считаются разделителями пустых строк (например, Аргумент sep может состоять из нескольких символов (например, Если sep не указано или установлено значение | a = «Гомер Джей Симпсон» a = «Гомер-Джей-Симпсон» a = «Гомер, Барт,» a = «Гомер ,, Барт» a = «Гомер <> Барт <> Мардж» Результат [«Гомер», «Джей», «Симпсон»] ["Гомер", "Джей-Симпсон"] ['Гомер', '', 'Барт', ''] ['Гомер', ', Барт'] [«Гомер», «Барт», «Мардж»] | ||||||||||||||||||||||||
Splitlines ([keepends]) | Возвращает список строк в строке с разрывом по границам строки.Разрывы строк не включаются в результирующий список, если не указан keepends и его значение — Этот метод разбивается на следующие границы строки.
| a = «Чай \ n \ nи кофе \ rчашки \ r \ n» печать (a.splitlines ()) Результат ["Чай", "", "и кофе", "чашки"] ['Чай \ n', '\ n', 'и кофе \ r', 'чашки \ r \ n'] | ||||||||||||||||||||||||
начинается с (префикс [, начало [, конец ]]) | Возвращает | a = «Гомер» Результат Верно Ложь Правда Ложь Правда | ||||||||||||||||||||||||
полоса ([ chars ]) | Возвращает копию строки с удаленными начальными и конечными символами.Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение Обратите внимание, что аргумент chars не является префиксом или суффиксом — все комбинации его значений удаляются. | a = «Пчела» a = «—— Пчела ——» Результат Пчела! Пчела | ||||||||||||||||||||||||
свопкейс () | Возвращает копию строки с символами верхнего регистра, преобразованными в нижний регистр и наоборот. Обратите внимание, что использование | a = «Гомер Симпсон» Результат ГОМЕР СИМПСОН | ||||||||||||||||||||||||
название () | Возвращает версию строки в заглавном регистре.Регистр заголовка — это когда слова начинаются с символа верхнего регистра, а остальные символы — с нижнего регистра. Используйте | a = «чай и кофе» a = «ЧАЙ И КОФЕ» Результат Чай и кофе Чай и кофе | ||||||||||||||||||||||||
перевести ( таблица ) | Возвращает копию строки, в которой каждый символ был сопоставлен с данной таблицей перевода.Таблица должна быть объектом, который реализует индексацию через Вы можете использовать | frm = «SecrtCod» Результат 123425 6782 | ||||||||||||||||||||||||
верх () | Возвращает копию строки, в которой все символы в регистре преобразованы в верхний регистр. | a = «пчела» Результат пчела | ||||||||||||||||||||||||
zfill ( ширина ) | Возвращает копию строки, заполненную слева цифрами ASCII | а = «36» а = «-36» а = «+36» Результат 00036 -0036 +0036 |
На этой странице: .startwith (), .endswith (), in, .count (), .upper (), .lower (), .capitalize (), .title (), .replace () и .strip (). Также: составное приложение, например .lower (). Count (). Испытания для субстрингового капота.startswith () проверяет наличие префикса. При вызове как x.startswith (y) он возвращает True, если строка x начинается со строки префикса y, в противном случае — False. Примеры:
С другой стороны, .endswith () проверяет суффикс-капюшон. При вызове как x.endswith (y) он возвращает True, если строка x заканчивается указанной строкой суффикса y, в противном случае — False. Примеры:
А как насчет подстрок посередине? Что ж, строки не имеют назначенного метода, но здесь можно использовать универсальный оператор in. Поскольку in не является строковым МЕТОДОМ, он использует другой синтаксис y в x:
Подстрока подсчета.count () возвращает количество вхождений данной подстроки. Возвращаемое значение — целое число:
Корпусные манипуляторы.upper () — метод в верхнем регистре. Он возвращает новую строку, в которой каждый символ находится в верхнем регистре..lower () делает обратное: он возвращает новую строку, в которой каждый символ в нижнем регистре.
.capitalize () превращает только самый первый символ во всей строке в заглавную букву, а .title () возвращает строку, в которой каждое слово начинается с заглавной буквы:
Преобразование строки.replace () принимает два параметра. Когда вызывается как x.replace (y, z), возвращается новая строка, в которой все экземпляры y в x заменяются на z.
.replace () можно использовать для удаления подстрок, указав пустую строку » в качестве второго параметра:
Иногда строки приходят с пробельными символами с обоих концов, и вам нужно их удалить..strip () — это метод, который нужно использовать:
Составное приложениеКогда строковый метод возвращает строковый тип, можно добавить другой строковый метод.Ниже метод .replace () вызывается несколько раз, чтобы удалить все «гласные» символы:
В приведенном ниже примере.count () используется на выходе .lower (). Первоначально было только два счета «sh», потому что «Sh» не совпадало. После того, как вся струна опущена, «sh» соответствует три раза.
Здесь важен порядок между двумя методами.Ниже сначала применяется .count (), а затем .lower (). Это не работает, потому что .count () возвращает целое число, а .lower () не работает с целочисленным типом.
|
Строковые методы Python: пошаговое руководство
Python имеет много методов, используемых исключительно для строк.Строковые методы Python включают upper ()
, lower ()
, capitalize ()
, title ()
и другие. Эти строковые методы полезны для манипулирования, редактирования и работы со строками.
Найди свой матч на тренировочном лагере
- Карьера Карма подойдет вам с лучшими техническими учебными курсами
- Получите эксклюзивные стипендии и подготовительные курсы
Найди свой матч на тренировочном лагере
- Карьера Карма подойдет вам с лучшими техническими учебными курсами
- Получите эксклюзивные стипендии и подготовительные курсы
Строки являются одним из основных типов данных, используемых в программировании, и они позволяют компьютерам работать с текстом.Например, строка может использоваться для хранения имени пользователя или его адреса электронной почты в программе Python.
Python включает несколько строковых методов, которые можно использовать для изменения и управления строками. Эти функции встроены в Python и поэтому готовы к использованию без импорта каких-либо библиотек.
В этом руководстве мы разберем несколько наиболее распространенных строковых методов, с которыми вы, вероятно, столкнетесь в Python, и рассмотрим примеры их использования.
Обновление строки
Строки позволяют хранить текст при программировании и объявляются в одинарных кавычках ‘’
или двойных кавычках ‘’
в Python.Хотя вы можете использовать как одинарные, так и двойные кавычки, когда вы решите, какие из них использовать, вы должны поддерживать их согласованность во всей программе. Вот пример объявления строки:
"Это пример строки в Python."
Мы можем распечатать строку с помощью функции print ()
:
print («Это пример строки!»)
Наша программа возвращает: Это пример строки!
Когда вы работаете со строкой, вы можете объединить ее с другой строкой, чтобы создать новую.В программировании мы называем это конкатенацией строк. Чтобы объединить две строки, мы используем оператор +
. Вот пример функции print ()
, которая объединяет две строки вместе:
81% участников заявили, что после буткемпа они почувствовали себя более уверенными в своих перспективах трудоустройства в сфере высоких технологий. Попадите на буткемп сегодня.
Найдите свой матч на учебном лагере
Средний выпускник учебного лагеря потратил менее шести месяцев на переходную карьеру, от начала учебного лагеря до поиска своей первой работы.
Начните карьеру сегодня
print («Пример» + «Строка»)
Наша программа возвращает: ExampleString
. Обратите внимание, что когда мы объединяем наши строки, пробелы не включаются. Если мы хотим включить пробел, мы должны добавить пробельный символ в наши строки.
Теперь, когда мы изучили основы работы со строками, мы можем приступить к изучению строковых методов Python.
Струны верхнего и нижнего регистра
Две из наиболее распространенных строковых функций в Python — это те, которые позволяют вам изменять регистр ваших строк на верхний или нижний регистр.Функции upper (),
и lower ()
вернут строку, в которой все исходные буквы в строке преобразованы в верхний или нижний регистр.
Когда вы используете функции upper ()
или lower ()
, возвращаемая строка будет новой строкой, а существующая строка останется прежней.
Вот пример использования класса upper ()
для преобразования строки в верхний регистр:
string_example = "Пример строки" print (string_example.верхний ())
Наша программа возвращает:
Если мы хотим, чтобы наша строка отображалась в нижнем регистре, мы могли бы использовать функцию lower ()
следующим образом:
Найди свой матч на тренировочном лагере
- Карьера Карма подойдет вам с лучшими техническими учебными курсами
- Получите эксклюзивные стипендии и подготовительные курсы
print (string_example.нижний ())
Наш код возвращает:
Кроме того, вы можете использовать метод capitalize (),
, чтобы использовать заглавные буквы в первом символе строки, и метод title ()
, чтобы сделать первую букву каждого слова в строке заглавной.
Эти функции полезны, если вы хотите сравнить строки и хотите, чтобы регистры этих строк были согласованными. Это важно, потому что сравнения в Python чувствительны к регистру. Например, вы можете преобразовать адрес электронной почты пользователя в нижний регистр, чтобы сравнить его с тем, который есть в вашем файле.
Длина строки
Когда вы работаете со строкой, вы можете узнать длину этой строки. Строковый метод len ()
Python может использоваться для возврата количества символов в строке.
Эта функция полезна, если вы хотите, например, установить минимальную или максимальную длину поля формы. Если вы хотите, чтобы адрес электронной почты пользователя состоял не более чем из 50 символов, вы можете использовать len ()
, чтобы узнать длину сообщения электронной почты и выдать ошибку, если она превышает 50 символов.
Вот пример программы, которая проверяет длину строки:
string_length = "Какова длина этой строки?" печать (длина (длина_строки))
Наша программа возвращает: 34. В нашем коде мы объявили переменную string_length
, в которой хранится строка Какова длина этой строки?
Затем, в следующей строке, мы использовали метод len (string_length)
, чтобы узнать длину нашей строки, и передали ее через метод print (), чтобы мы могли видеть длину в нашей консоли.
Помните, что функция длины будет считать каждый символ в строке, которая включает буквы, числа и символы пробела.
Методы логических строк
Существует ряд строковых методов Python, которые возвращают логическое значение. Эти методы полезны, если мы хотим узнать больше о характеристиках строки. Например, если мы хотим проверить, написана ли строка в верхнем регистре или она содержит только числа, мы могли бы использовать метод логической строки, который вернет истину, если все символы в верхнем регистре.
Вот список строковых методов Python, которые возвращают True, если их условие выполнено:
-
str.isupper ()
: Все буквенные символы строки — прописные -
str.islower ()
: Все алфавитные символы строки — строчные -
str.istitle ()
: Строка находится в верхнем регистре -
str.isspace ()
: строка состоит только из символов пробела -
str.isnumeric ()
: строка содержит только числовые символы -
str.isalnum ()
: строка содержит только буквенно-цифровые символы (без символов) -
str.isalpha ()
: строка содержит только буквенные символы (без цифр и символов)
Давайте рассмотрим некоторые из этих методов логических строк. Вот пример использования функции isupper ()
, чтобы проверить, содержит ли строка только символы верхнего регистра:
«Карьера Карма вошла в мою жизнь, когда я больше всего в ней нуждалась, и быстро помогла мне сыграть в буткемпе.Через два месяца после выпуска я нашла работу своей мечты, которая соответствовала моим ценностям и целям в жизни! »
Venus, инженер-программист Rockbot
Найдите свой матч на учебном лагере
full_name = "ДЖОН ЭППЛЕСИД" печать (полное_имя.isupper ())
Наша программа возвращает: True. Переменная full_name
содержит значение с текстом, полностью написанным в верхнем регистре, поэтому наша функция isupper ()
оценивается как True и возвращает значение True.
Точно так же мы можем использовать функцию istitle ()
, чтобы проверить, находится ли строка в регистре заголовка:
предложение = "Это предложение." печать (предложение.istitle ())
Наш код возвращает: Ложь. Поскольку наша строка не в заглавном регистре — каждый символ не начинается с заглавной буквы — наш метод istitle ()
оценивается как False.
Логические строковые методы могут быть полезны при получении пользовательского ввода, который вы хотите проверить, или если у вас есть два точных значения, которые вы хотите сравнить.
начинается и заканчивается
Допустим, у вас есть строка, и вы хотите проверить, начинается она или заканчивается определенным значением.Например, у вас может быть имя пользователя, и вы хотите проверить, начинается ли оно с F
. Мы можем использовать функции startwith ()
и endwith ()
для проверки наших строк.
Метод startwith ()
возвращает True, если строка начинается с определенного значения, а метод endwith ()
возвращает True, если строка заканчивается определенным значением. В противном случае строковые методы возвращают false.
Оба метода принимают три параметра. Первое — это ценность, которую вы ищете.При желании вы можете указать начальный индекс в строке, где ваш поиск должен начинаться со второго параметра, и вы также можете указать конечный индекс, где ваш поиск должен заканчиваться третьим.
Вот пример работы функции startwith ()
:
full_name = "Билл Джефферсон" print (full_name.startswith ("Bill"))
Наша программа возвращает: True.
Если мы хотим проверить, появляется ли Bill
в нашей строке, начиная с четвертой буквы в нашей строке — элемент со значением индекса 3
, потому что индексы начинаются с — мы могли бы использовать следующий код:
full_name = "Билл Джефферсон" печать (полное_имя.начинается с ("Билл", 3))
Наш код возвращает False
, потому что Bill
не появляется в строке после значения индекса 3
.
Разделение и соединение строк
Кроме того, вы можете использовать методы join ()
и split ()
для управления строками в Python.
Метод join ()
берет все элементы в повторяемой строке и присоединяет их к другой строке. Вот пример строкового метода join ()
Python в действии:
string = "Строка" "ИКС".присоединиться (строка)
Наш код возвращает следующее: SXtXrXiXnXg
. Произошло то, что строка join ()
прошла через каждую букву в переменной строка
и добавила X
после каждой буквы.
Метод join ()
может быть полезен, если вы хотите объединить определенное значение вместе со строкой. Этот метод также часто используется для объединения списка строк. Вот пример использования join ()
для объединения списка строк в одну:
print (",".присоединиться ([«Люси», «Эмили», «Дэвид»])
Наш код возвращает следующее: Люси
, Эмили
, Дэвид
. Теперь наш список имен находится в одной строке, а не в массиве.
Мы также можем использовать строковый метод split ()
для разделения строки и возврата списка строк. Вот пример метода split ()
, который используется для разделения предложения на список строк:
example_sentence = "Это предложение." print (example_sentence.сплит ())
Наш код возвращает следующее:
[«Это», «есть», «а», «предложение».]
Как видите, наша исходная строка была разделена на четыре элемента, и был создан новый список этих элементов.
Метод split ()
возвращает список строк, разделенных пробелами, если не указан другой параметр, но если вы хотите разделить строку другим символом, вы можете. Вот пример программы, которая делит строку на основе запятых в этой строке:
names = "Люси, Эмили, Дэвид" печать (имена.split (","))
Наш код возвращает:
[«Люси», «Эмили», «Дэвид»]
Как вы можете видеть, наша программа разделила наши строки значениями запятой в нашей начальной строке и создала массив с новыми отдельными значениями.
Просмотрите Repl.it из этого руководства:
Заключение
Строки — это полезный тип данных, который позволяет кодировщикам сохранять текстовые значения в своих программах. В этом руководстве мы изучили некоторые из наиболее распространенных встроенных строковых методов Python, которые вы можете использовать для управления строками.
Мы обсудили методы upper (),
и lower ()
и то, как они могут помочь вам в работе с кейсами в Python, метод len ()
и то, как он может помочь вам получить длину строки, и мы исследовал методы логических строк, доступные в Python.
Мы также обсудили, как использовать join ()
и split ()
и как проверить, начинается ли строка с подстроки или заканчивается на ней.
Стоит отметить, что существует ряд других строковых методов, таких как ljust ()
, rjust ()
и zfill ()
, и эта статья лишь поверхностно.Теперь вы готовы приступить к работе со строками в Python как эксперт!
10 самых полезных строковых методов Python
Строковые данные — это символы массива, который содержит один или несколько символов в качестве значения для любого языка программирования. В строковых данных обычно используются все печатаемые символы, такие как алфавиты, числа, специальные символы и т. Д. Код ASCII и Unicode в основном используются для преобразования любого символа в число, понятное компьютеру. Python использует символы Unicode для строковых данных.Нам необходимо выполнять различные типы задач в зависимости от цели программирования строковых данных, таких как поиск конкретного символа или символов, использование первого символа с заглавной буквы, перевод всех символов в верхний регистр и т. Д. Python имеет множество встроенных строковых методов для выполнения этих типов. задач очень легко. В этой статье описаны 10 наиболее полезных строковых методов Python.
Использование метода format ()
format () метод является важным методом Python для создания форматированного вывода.Он имеет множество применений и может применяться как к строковым, так и к числовым данным для генерации форматированного вывода. Как этот метод можно использовать для форматирования строковых данных на основе индекса, показано в следующем примере.
Синтаксис:
Строка и позиция заполнителя определяются внутри фигурных скобок ({}). Он возвращает отформатированную строку на основе строки и значений, переданных в позиции заполнителя.
Пример:
В следующем сценарии показаны четыре типа форматирования.В первом выводе используется значение индекса {0}. На втором выходе позиция не назначена. На третьем выходе назначены две последовательные позиции. В четвертом выводе определены три неупорядоченные позиции.
#! / usr / bin / env python3
# Применить единый индекс со значением
print («Изучите {0} программирование» .format («Python»))
# Применить форматирование без значения индекса
print («Оба {} и { } являются языками сценариев «.format (» Bash «,» Python «))
# Применение множественного индекса со значением индекса
print (» \ nStudent ID: {0} \ nStudent Nmae: {1} \ n «.format («011177373», «Meher Afroz»))
# Применение множественного указателя без какого-либо заказа
print («{2} является студентом отделения {0}, и он учится в семестре {1}» .format (» ЦГП »,
« 10 »,« Фархан Актер »))
Вывод:
Использование метода split ()
Этот метод используется для разделения любых строковых данных на основе определенного разделителя или ограничителя. Он может принимать два аргумента, и оба они необязательны.
Синтаксис:
split ([separator, [maxsplit]])
Если этот метод используется без аргументов, то по умолчанию в качестве разделителя будет использоваться пробел.В качестве разделителя можно использовать любой символ или список символов. Второй необязательный аргумент используется для определения предела разделения строки. Он возвращает список строк.
Пример:
Следующий сценарий показывает использование метода split () без аргументов, с одним аргументом и с двумя аргументами. Пробел используется для разделения строки, когда не используется аргумент. Затем двоеточие (:) используется в качестве аргумента-разделителя.Запятая (,) используется как разделитель, а 2 используется как номер разделения в последнем операторе разделения.
#! / usr / bin / env python3
# Определить первое строковое значение
strVal1 = «Python сейчас очень популярный язык программирования»
# Разделить строку по пробелу
splitList1 = strVal1.split ()
# Определить значение второй строки
strVal2 = «Python: PERL: PHP: Bash: Java»
# Разделить строку на основе ‘:’
splitList2 = strVal2.split (‘:’)
# Определить значение третьей строки
strVal3 = «Имя: Фиаз Ахмед, Пакет: 34, Семестр: 10, Отдел: CSE»
# Разделить строку на основе ‘,’ и разделить строку на три части
splitList3 = strVal3.split (‘,’, 2)
print («Вывод первого разбиения: \ n», splitList1)
print («Вывод второго разбиения: \ n», splitList2)
print («Вывод третьего разбиения : \ n «, splitList3)
Вывод:
Использование метода find ()
find () Метод используется для поиска позиции определенной строки в основной строке и возврата позиции, если строка существует в основной строке.
Синтаксис:
найти (searchText, [начальная_позиция, [конечная_позиция]])
Этот метод может принимать три аргумента, первый из которых является обязательным, а два других — необязательными.Первый аргумент содержит строковое значение, в котором будет выполняться поиск, второй аргумент определяет начальную позицию поиска, а третий аргумент определяет конечную позицию поиска. Он возвращает позицию searchText , если он существует в основной строке, в противном случае возвращает -1.
Пример:
Использование метода find () с одним аргументом, двумя аргументами и третьим аргументом показано в следующем сценарии. Первый результат будет -1, потому что поисковый текст — « python », а переменная str содержит строку « Python ».Второй вывод вернет действительную позицию, потому что слово « program » существует на str после позиции 10 . Третий вывод вернет действительную позицию, потому что слово « заработать » существует в пределах от 0 до 5 позиции str .
#! / usr / bin / env python3
# определение строковых данных
str = ‘Learn Python programming’
# Поиск позиции слова ‘python’ в начальном
print (str.find (‘python’))
# Искать строку ‘program’ с позиции 10
print (str.find (‘program’, 10))
# Искать слово ‘зарабатывать’ с позиции 0 и в пределах следующих 5 символов
print (str.find (‘Earn’, 0, 5))
Вывод:
Использование метода replace ()
replace () Метод используется для замены любой конкретной части строковых данных другой строкой, если совпадение найдено. Может принимать три аргумента. Два аргумента являются обязательными, а один — необязательным.
Синтаксис:
строка.replace (search_string, replace_string [, counter])
Первый аргумент принимает строку поиска, которую вы хотите заменить, а второй аргумент принимает строку замены. Третий необязательный аргумент устанавливает предел для замены строки.
Пример:
В следующем скрипте первая замена используется для замены слова « PHP » словом « Java » в содержании str . Слово для поиска существует по адресу str, , поэтому слово «PHP» будет заменено словом « Java ».Третий аргумент метода замены используется в следующем методе замены и заменяет только первое совпадение искомого слова.
#! / usr / bin / env python3
# Определить строковые данные
str = «Мне нравится PHP, но мне больше нравится Python»
# Заменить конкретную строку строковых данных, если они найдены
replace_str1 = str.replace («PHP» , «Java»)
# Распечатать исходную строку и замененную строку
print («Исходная строка:», str)
print («Замененная строка:», replace_str1)
# Заменить конкретную строку строковых данных для первое совпадение
replace_str2 = str.replace («нравится», «не нравится», 1)
print («\ nОригинальная строка:», str)
print («Замененная строка:», replace_str2)
Вывод:
Использование метода join ()
Метод join () используется для создания новой строки путем объединения другой строки со строкой, списком строк или кортежем данных строк.
Синтаксис:
Он имеет только один аргумент, который может быть строкой, списком или кортежем, а разделитель содержит строковое значение, которое будет использоваться для конкатенации.
Пример:
В следующем сценарии показано использование метода join () для строки, списка строки и кортежа строк. ‘,’ Используется как разделитель для строки, пробел используется как разделитель для списка, а ‘:’ используется как разделитель для кортежа.
#! / usr / bin / env python3
# Применить соединение к строковым данным
print (‘Соединение каждого символа запятой:’, ‘,’. join (‘linuxhint’))
# Применить соединение к списку строк
print ( ‘Объединение списка строк с пробелом:’, ».join ([‘I’, ‘like’, ‘programming’]))
# Применить объединение к кортежу строк
print (‘Объединение кортежа строк с двоеточием:’, ‘:’. join ((‘011156432’, ‘ Мехназ, ’10’, ’45’)))
Вывод:
Использование метода полосы ()
strip () метод используется для удаления пробелов с обеих сторон строки. Есть два связанных метода удаления пробелов. Метод lstrip () для удаления пробелов с левой стороны и метод rstrip () для удаления пробелов с правой стороны строки.Этот метод не принимает никаких аргументов.
Синтаксис:
Пример:
В следующем сценарии показано использование метода strip () для строкового значения, которое содержит много пробелов до и после строки. Дополнительный текст добавляется к выходным данным метода strip (), чтобы показать, как этот метод работает.
#! / usr / bin / env python3
# Определение строковых данных с пробелом
strVal = «Добро пожаловать в LinuxHint»
# Вывод на печать до и после полосы
print («Вывод до полосы ():», strVal)
print («Вывод после strip ():», strVal.strip (), «(Добавлено для проверки)»)
Вывод:
Использование метода capitalize ()
capitalize () Метод используется для преобразования первого символа строковых данных с заглавной буквы и перевода остальных символов в нижний регистр.
Синтаксис:
Этот метод не принимает никаких аргументов. Он возвращает строку после преобразования первого символа в верхний регистр, а остальных символов в нижний регистр.
Пример:
В следующем сценарии строковая переменная определяется сочетанием символов верхнего и нижнего регистра.Метод capitalize () преобразует первый символ строки в заглавную букву, а остальные символы в маленькие буквы.
#! / usr / bin / env python3
# Определите строку
strVal = ‘jubair Hosain IS a VeRy GooD programmer.’
# Применить метод capitalize ()
print (strVal.capitalize ())
Вывод:
Использование метода count ()
count () метод используется для подсчета того, сколько раз конкретная строка появляется в тексте.
Синтаксис:
string.count (search_text [, начало [, конец]])
У этого метода есть три аргумента. Первый аргумент является обязательным, а два других аргумента — необязательными. Первый аргумент содержит значение, которое требуется для поиска в тексте. Второй аргумент содержит начальную позицию поиска, а третий аргумент содержит конечную позицию поиска.
Пример:
Следующий сценарий показывает три различных использования метода count () .Первый метод count () будет искать слово ‘is ’ в переменной strVal. Второй метод count () выполняет поиск того же слова с позиции 20 . Третий метод count () выполняет поиск того же слова в позиции с 50 до 100 .
#! / usr / bin / env python3
# Определите длинный текст с повторяющимися словами
strVal = ‘Python — мощный язык программирования. Очень просто использовать.
Это отличный язык для изучения программирования для начинающих.’
# Использовать метод count с аргументом поиска
print («Слово’ is ‘появилось% d раз»% (strVal.count («is»)))
# Использовать метод count с аргументом поиска и начальной позицией
print ( «Слово ‘is’ появилось% d раз после позиции 20″% (strVal.count («is», 20)))
# Использовать метод count с аргументом поиска, начальной и конечной позицией
print («The word ‘ is ‘появлялось% d раз в пределах от 50 до 100 «% (strVal.count (» is «, 50, 100)))
Вывод:
Использование метода len ()
len () метод используется для подсчета общего количества символов в строке.
Синтаксис:
Этот метод принимает любое строковое значение в качестве аргумента и возвращает общее количество символов этой строки.
Пример:
В следующем сценарии строковая переменная с именем strVal объявляется со строковыми данными. Затем будет напечатано значение переменной и общее количество символов, которые существуют в переменной.
#! / usr / bin / env python3
# Определите строковое значение
strVal = «Python легко освоить для новичка.»
# Распечатать строковое значение
print (» Строковое значение: «, strVal)
# Применить метод len ()
print (» Всего символов: «, len (strVal))
Вывод:
Использование метода index ()
Метод
index () работает так же, как метод find () , но между этими методами есть одно различие. Оба метода возвращают позицию искомого текста, если строка существует в основной строке. Если искомого текста нет в основной строке, тогда метод find () возвращает -1, но метод index () генерирует ValueError .
Синтаксис:
string.index (search_text [, start [, end]])
У этого метода есть три аргумента. Первый аргумент является обязательным и содержит текст для поиска. Два других аргумента являются необязательными и содержат начальную и конечную позицию поиска.
Пример:
index () метод используется 4 раза в следующем скрипте. try-excep t-блок используется здесь для обработки ValueError . Index () Метод используется с одним аргументом в первом выводе, который будет искать слово « мощный » в переменной strVal. Затем, , метод index () будет искать слово «программа» с позиции 10 , которая существует в strVal . Затем метод index () выполнит поиск слова « is» в позиции с 5 до 15 , которая существует в strVal . Последний метод index () будет искать слово « his» в пределах от 0 до 25 , которое не существует в strVal .
#! / usr / bin / env python3
# Определите строку
strVal = ‘Python — мощный язык программирования.’
# Применить метод index () с разными аргументами
try:
print (strVal.index (‘мощный’))
print (strVal.index (‘program’, 10))
print (strVal.index (‘is ‘, 5, 15))
print (strVal.index (‘ his ‘, 0, 25))
# Поймать ошибку значения и распечатать пользовательское сообщение
, кроме ValueError:
print («Строка поиска не найдена»)
Вывод:
Вывод:
Наиболее часто используемые встроенные методы строки Python описаны в этой статье на очень простых примерах, чтобы понять использование этих методов и помочь в использовании нового Python.
Python String содержит учебник с .find (), .index () и .count ()
Если вы хотите найти или заменить элементы в строке, Python имеет несколько встроенных методов, которые могут помочь вам найти целевую строку для указанной подстроки.
.find ()
Метод
Синтаксис
string.find (подстрока, начало, конец)
Примечание: начало
и конец
являются необязательными аргументами.
Из приведенного выше синтаксиса можно заметить, что файл .Метод find ()
принимает желаемую подстроку в качестве обязательного аргумента. Вы можете указать два других аргумента: включающую начальную позицию и исключительную конечную позицию.
Поиск подстроки
В примере кода вы ищите Waldo
в строке Where's Waldo?
. Метод .find ()
возвращает самый низкий индекс в строке, по которому он может найти подстроку, в данном случае восемь.
my_string = "Где Уолдо?"
моя_строка.найти ("Вальдо")
8
При поиске Wenda
возвращается -1
, поскольку подстрока не найдена.
my_string.find («Венда»)
-1
Давайте посмотрим, сможете ли вы найти Waldo
между нулевым и пятым символами. В коде вы указываете нулевую начальную позицию и конечную позицию как шесть, поскольку эта позиция не является включительной.
my_string = "Где Уолдо?"
my_string.find ("Вальдо", 0, 6)
-1
Метод .find ()
не находит подстроку и возвращает -1
, как показано выше.
.index ()
Метод
Синтаксис
string.index (подстрока, начало, конец)
Примечание: начало
и конец
являются необязательными аргументами.
Из приведенного выше синтаксиса можно заметить, что метод .index ()
принимает желаемую подстроку в качестве обязательного аргумента.Он также может принимать необязательные начальные и конечные позиции.
Поиск подстроки
В этом примере мы снова ищем Уолдо, используя .index ()
.
my_string = "Где Уолдо?"
my_string.index ("Вальдо")
8
Получаем снова восемь. Когда мы ищем подстроку, которой нет, у нас есть разница.
my_string.index («Венда»)
Файл "", строка 1, в
ValueError: подстрока не найдена
Модель .index ()
вызывает исключение, как мы видим в выводе. Мы можем справиться с этим с помощью блока try except.
my_string = "Где Уолдо?"
попробовать:
my_string.index («Венда»)
кроме ValueError:
print («Не найдено»)
Выше вы можете наблюдать синтаксис. Часть try проверит данный код. Если появится какая-либо ошибка, будет выполнена часть except, получив в результате следующий вывод.
«Не найдено»
.count ()
Метод
Метод .count ()
ищет указанную подстроку в целевой строке. Он возвращает количество неперекрывающихся вхождений. Проще говоря, сколько раз подстрока присутствует в строке.
Синтаксис
Синтаксис .count ()
очень похож на другие методы, как мы можем заметить.
string.count (подстрока, начало, конец)
Примечание: начало
и конец
являются необязательными аргументами.
Количество подстрок
В этом примере мы используем метод .count ()
, чтобы узнать, сколько раз появляется фрукт.
my_string = "Сколько фруктов у вас в корзине?"
my_string.count ("фрукт")
2
На выходе мы видим, что это два.
Затем мы можем ограничить появление фруктов от нуля до пятнадцатого символа в строке, как мы можем наблюдать в приведенном ниже коде.
my_string.count ("фрукт", 0, 16)
1
Метод вернет 1
. Помните, что начальная позиция является включительной, а конечная — нет.
.replace
Метод
Иногда вам может потребоваться заменить вхождения подстроки новой подстрокой. В этом случае Python предоставляет нам метод .replace
.
Синтаксис
string.replace (старый, новый, количество)
Примечание. count
— необязательный аргумент.
Как мы видим в синтаксисе выше, он принимает три аргумента: заменяемую подстроку, новую строку для ее замены и необязательное число, указывающее, сколько вхождений нужно заменить.
Замена подстроки
В примере кода мы заменяем подстроку house на car.
my_string = "Красный дом находится между синим домом и старым домом"
print (my_string.replace ("дом", "машина"))
Красная машина находится между синей машиной и старой машиной
Метод вернет копию с замененными всеми домашними подстроками.
Замена определенного количества вхождений
В этом примере мы указали, что хотим заменить только 2 экземпляра.
печать (my_string.replace ("дом", "машина", 2))
Красная машина находится между синей машиной и старым домом
В выходных данных мы видим, что метод возвращает копию строки, в которой первые два вхождения house заменены на car.
Интерактивный пример
В приведенном ниже примере вы:
- Найти, встречается ли подстрока
субъект
между символами с индексами37
и41
включительно.Если он не обнаружен, выведите выпискуWord not found
. - Замените
«актер», «актер»
на подстроку «: актер,
», если«актер»
встречается только два раза. - Заменить
актер актер актер
подстрокой актер, еслиактер
появляется три раза.
для фильма в кино:
# Найдите, встречается ли актер между 37 и 41 включительно
если movie.find ("актер", 37, 42) == -1:
print («Слово не найдено»)
# Подсчитать вхождения и заменить два на один
Элиф фильм.count ("актер") == 2:
print (movie.replace («актер, актер», «актер»))
еще:
# Заменить три вхождения одним
print (movie.replace («актер, актер, актер», «актер»))
Когда мы запускаем приведенный выше код, он дает следующий результат:
Слово не найдено
Я вам верю, я всегда говорил, что актер великолепен в каждом фильме, который он сыграл
Удивительно, насколько устрашающе выглядит актер Нортон с бритой головой и свастикой на груди.
Попробуйте сами.
Чтобы узнать больше о поиске и замене строк, посмотрите это видео из нашего курса Регулярные выражения в Python.
Этот контент взят из курса «Регулярные выражения в Python» DataCamp, подготовленного Марией Евгенией Изаугарат.
15 строковых методов Python, которые необходимо знать
Фото: Hello I’m Nik на Unsplash
Python — отличный язык. Его относительно легко изучить, и он имеет интуитивно понятный синтаксис. Богатый выбор библиотек также способствует популярности и успеху Python.
Однако речь идет не только о сторонних библиотеках. Базовый Python также предоставляет множество методов и функций для ускорения и упрощения типичных задач в области науки о данных.
В этой статье мы рассмотрим 15 встроенных строковых методов в Python. Возможно, вы уже знакомы с некоторыми из них, но мы также увидим некоторые из редких.
Эти методы говорят сами за себя, поэтому я сосредоточусь на примерах, чтобы продемонстрировать, как их использовать, а не объяснять, что они делают.
1. Использовать заглавные буквы
Делает первую букву заглавной.
txt = "Python потрясающий!"
txt.capitalize ()
«Python потрясающий!»
2. Верхний
Делает все буквы прописными.
txt = "Python потрясающий!"
txt.upper ()
"PYTHON УДИВИТЕЛЬНЫЙ!"
3. Нижняя
Делает все буквы строчными.
txt = "PYTHON УДИВИТЕЛЬНЫЙ!"
txt.lower ()
"Python - это круто!"
4. Isupper
Проверяет, все ли буквы в верхнем регистре.
txt = "PYTHON УДИВИТЕЛЬНЫЙ!"
txt.isupper ()
Правда
5. Исловер
Проверяет, все ли буквы строчные
txt = "PYTHON УДИВИТЕЛЬНЫЙ!"
txt.islower ()
Ложь
Следующие 3 метода похожи, поэтому я сделаю примеры, включающие их все.
6. Исчисленное
Проверяет, все ли символы числовые.
7. Исальфа
Проверяет, все ли символы в алфавите.
8. Исальнум
Проверяет, все ли символы являются буквенно-цифровыми (т.е. буквой или цифрой).
# Пример 1
txt = "Python"
печать (txt.isnumeric ())
Ложь
печать (txt.isalpha ())
Правда
печать (txt.isalnum ())
Правда
# Пример 2
txt = "2021"
печать (txt.isnumeric ())
Правда
печать (txt.isalpha ())
Ложь
печать (txt.isalnum ())
Правда
# Пример 3
txt = "Python2021"
печать (txt.isnumeric ())
Ложь
печать (txt.isalpha ())
Ложь
печать (txt.isalnum ())
Правда
# Пример 4
txt = "Python-2021"
печать (txt.isnumeric ())
Ложь
печать (txt.isalpha ())
Ложь
печать (txt.isalnum ())
Ложь
9. Граф
Подсчитывает количество вхождений данного символа в строку.
txt = "Наука о данных"
txt.count ("е")
2
10. Найдите
Возвращает индекс первого вхождения данного символа в строку.
txt = "Наука о данных"
текст.Найди")
1
Мы также можем найти второе или другое вхождение символа.
Если мы передаем последовательность символов, метод find возвращает индекс, с которого начинается последовательность.
11. Начинается с
Проверяет, начинается ли строка с данного символа. Мы можем использовать этот метод как фильтр в понимании списка.
mylist = ["Джон", "Джейн", "Эмили", "Джек", "Эшли"]
j_list = [имя для имени в моем списке, если имя.начинается с ("J")]
j_list
[«Джон», «Джейн», «Джек»]
12. Окончание
Проверяет, заканчивается ли строка данным символом.
txt = "Python"
txt.endswith ("н")
Правда
Оба метода endwith и startwith чувствительны к регистру.
txt = "Python"
txt.startswith ("p")
Ложь
txt.startswith ("P")
Правда
13.Заменить
Заменяет строку или ее часть заданным набором символов.
txt = "Python потрясающий!"
txt = txt.replace ("Python", "Наука о данных")
текст
«Наука о данных - это круто!»
14. Сплит
Он разбивает строку по вхождения указанного символа и возвращает список, содержащий каждую часть после разделения.
txt = 'Наука о данных - это здорово!'
текст.расколоть()
["Данные", "наука", "это", "круто!"]
По умолчанию он разделяется на пробелы, но мы можем сделать это на основе любого символа или набора символов.
15. Перегородка
Он разбивает строку на 3 части и возвращает кортеж, содержащий эти части.
txt = "Python потрясающий!"
txt.partition ("есть")
('Python', 'это', 'круто!')
txt = "Python потрясающий, и его легко выучить."
txt.partition ("и")
(«Python - это круто», «и», «его легко выучить».)
Метод разделения возвращает ровно 3 части. Если существует несколько вхождений символа, используемого для разделения, учитывается первый из них.
txt = "Python, наука о данных и машинное обучение"
txt.partition ("и")
(«Python», «и», «наука о данных и машинное обучение»)
Мы также можем проделать аналогичную операцию с методом разделения, ограничив количество разделений.Однако есть некоторые отличия.
- Метод split возвращает список
- Возвращенный список не включает символы, используемые для разделения
txt = "Python, наука о данных и машинное обучение"
txt.split ("и", 1)
["Python", "наука о данных и машинное обучение"]
Бонус
Спасибо Матеусу Феррейре за напоминание об одном из лучших строковых методов: join. Я тоже использую метод соединения, но забыл добавить его сюда.Он заслуживает того, чтобы попасть в список в качестве бонуса.
Метод соединения объединяет строки в коллекции в одну строку.
mylist = ["Джейн", "Джон", "Мэтт", "Джеймс"]
"-". присоединиться (мой список)
'Джейн-Джон-Мэтт-Джеймс'
Давайте также рассмотрим пример с кортежем.
mytuple = ("Наука о данных", "Машинное обучение") "и" .join (mytuple) 'Наука о данных и машинное обучение "
Заключение
При работе с данными мы много работаем с текстовыми данными.Более того, текстовые данные требуют гораздо большей предварительной обработки, чем простые числа. К счастью, встроенные в Python строковые методы способны выполнять такие задачи эффективно и плавно.
Спасибо за внимание. Пожалуйста, дайте мне знать, если у вас есть какие-либо отзывы.
Биография: Сонер Йылдырым — младший специалист по данным в Invent Analytics и блогер.
Оригинал. Размещено с разрешения.
Связанный:
Лучшая статья о строковых методах в Python — 3
Пример строковых методов
#STRING METHODS IN PYTHON (itvoyagers.in)
s = "itvoyagers welcome you"
print ('s', s)
print ("s.capitalize ()", s.capitalize ()) # возвращает строку с заглавной буквы
print ("s.count ('e', 0,22)", s.count ('e', 0,22))
print ("s.endswith ('s', 0,22)", s .endswith ('s', 0,22))
print ("s.endswith ('u', 0,22)", s.endswith ('u', 0,22))
print ( "s.find ('O', 0,22)", s.find ('O', 0,22)) # возвращает -1, если не найдено else index
print ("s.find ('e', 0,22) ", s.find ('e', 0,22)) # возвращает индекс, если найден
print (" s.index ('e', 0,22) ", s.index ('e', 0,22)) # возвращает индекс, если найден
# удалить комментарий из строки ниже для выполнения кода
#print ("s.index ('E', 0,22)" , s.index ('E', 0,22)) # возвращает ошибку, если не обнаружена
st = '5star'
print ('st', st)
print ("st.isalnum () ", st.isalnum ()) # возвращает True, только если буквы или цифры
st1 = 'star'
print ('st1', st1)
print (" st1.isalpha () ", st1.isalpha ()) # возвращает True, только если алфавиты
st2 = '5'
print ('st2', st2)
print (" st2.isdigit () ", st2 .isdigit ())
print ("s.islower ()", s.islower ()) #returns True - строка в нижнем регистре
print ("s.isupper ()", s.isupper ( )) #returns True - строка в верхнем регистре
st3 = ''
print ('st3', st3)
print ("st3.isspace ()", st3.isspace ()) #returns Истинно, если строка состоит только из пробелов
st4 = "Hello Python"
print ('st4', st4)
print ("st4.istitle () ", st4.istitle ()) # проверяет, находится ли строка в регистре заголовка
print (" len (s) ", len (s))
print (" s.lower () ", s .lower ())
print ("s.upper ()", s.upper ())
st5 = "Сегодня приятный день и теплая погода"
print ("st5", st5)
print ("st5.replace ('is', 'was', 1)", st5.replace ('is', 'was', 1))
print ("st5.replace (' is ',' was ', 1) ", st5.replace (' is ',' was ', 1))
print (" s.rfind ('O', 0,22) ", s.rfind ('O', 0,22))
print (" s.rfind ('e', 0,22) ", s.rfind (' e ', 0,22))
print ("s.rindex (' e ', 0,22)", s.rindex (' e ', 0,22))
#remove comment from below line выполнить код
#print ("s.rindex ('E', 0,22)", s.rindex ('E', 0,22))
st6 = "Python"
print ( "st6", st6)
print ("st6.