Python 3 методы строк: работа со строками, форматирование,методы split, strip

Содержание

Уроки по работе со строками pytrhon, методы строк ~ PythonRu

Предыдущий урок: Присвоение типа переменной

Строковые значения

В строковых значениях в Python с двух сторон ставятся либо одинарные кавычки, либо двойные кавычки. 'привет' — это то же самое, что и "привет".
Строки могут выводиться на экран с использованием функции вывода. Например: print("привет").
Как и во многих других популярных языках программирования, строки в Python это массивы байтов, которые представляют символы unicode. Однако у Python нет символьного типа данных, один символ — это просто строка с длиной 1. Квадратные скобки могут использоваться для доступа к элементам строки.
Получим символ с индексом 1 (помните, что первый символ имеет индекс 0):

a = "Привет, Мир!"  
print(a[1])

Вывод:

р

Подстрока. Получим часть строки с индекса 2 по 5 (запомните, подстрока не включает крайний индекс, в примере это b[5]):

b = "Привет, Мир!"  
print(b[2:5])

Вывод:

иве

Метод strip() удаляет любые пробелы с начала или конца строки:

a = " Привет, Мир! "  
print(a.strip())

Вывод:

Привет, Мир!

Метод len() возвращает длину строки:

a = "Привет, Мир!"  
print(len(a))

Вывод:

12
Подписывайтесь на телеграм каналы

Метод lower() возвращает строку в нижнем регистре:

a = "Привет, Мир!"  
print(a.lower())

Вывод:

привет, мир!

Метод upper() возвращает строку в верхнем регистре:

a = "Привет, Мир!"  
print(a.upper())

Вывод:

ПРИВЕТ, МИР!

Метод replace(x, y) заменяет часть строки x на строку y:

a = "Привет, Мир!"  
print(a.replace("Ми", "Мэ"))

Вывод:

Привет, Мэр!

Если менять “и” на “э”, получим “Прэвет, Мэр!”

Метод split(x) разбивает строку на список из подстроки, по разделителю x:

a = "Привет, Мир!"  
print(a.split(",")) 

Далее: Операторы в Python

методы для форматирования и преобразование в строку

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

Создание

Получить новую строку можно несколькими способами: при помощи соответствующего литерала либо же вызвав готовую функцию. Для начала рассмотрим первый метод, который продемонстрирован ниже. Здесь переменная string получает значение some text, благодаря оператору присваивания. Вывести на экран созданную строку помогает функция print.

string = 'some text'
print(string)

some text

Как видно из предыдущего примера, строковый литерал обрамляется в одиночные кавычки. Если необходимо, чтобы данный символ был частью строки, следует применять двойные кавычки, как это показано в следующем фрагменте кода. Из результатов его работы видно, что новая строка включает в себя текст some ‘new’ text, который легко выводится на экран.

string = "some 'new' text"
print(string)

some 'new' text

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

string = """some 'new' text
with new line here"""
print(string)

some 'new' text
with new line here

Специальные символы

Пользоваться тройными кавычками для форматирования строк не всегда удобно, так как это порой занимает слишком много места в коде. Чтобы задать собственное форматирование текста, достаточно применять специальные управляющие символы с обратным слэшем, как это показано в следующем примере. Здесь используется символ табуляции \t, а также знак перехода на новую строку \n. Метод print демонстрирует вывод нового объекта на экран.

string = "some\ttext\nnew line here"
print(string)

some    text
new line here

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

string = r"D:\dir\new"

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

Символ Назначение
\n Перевод каретки на новую строку
\b Возврат каретки на один символ назад
\f Перевод каретки на новую страницу
\r Возврат каретки на начало строки
\t Горизонтальная табуляция
\v Вертикальная табуляция
\a Подача звукового сигнала
\N Идентификатор базы данных
\u, \U 16-битовый и 32-битовый символ Unicode
\x Символ в 16-ричной системе исчисления
\o Символ в 8-ричной системе исчисления
\0 Символ Null

Очень часто испльзуется \n. С помощью него осуществляется в Python перенос строки. Рассмотрим пример:

print('first\nsecond')

first
second

Форматирование

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

string = "text"
number = 10
newString = "this is %s and digit %d" % (string, number)
print(newString)

this is text and digit 10

В приведенном ниже фрагменте кода демонстрируется использование форматирования для вывода строки с выравниванием по правому краю (общая длина символов указана как 10).

string = "text"
newString = "%+10s" % string
print(newString)

text

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

Символ Назначение
%d, %i, %u Число в 10-ричной системе исчисления
%x, %X Число в 16-ричной системе исчисления с буквами в нижнем и верхнем регистре
%o Число в 8-ричной системе исчисления
%f, %F Число с плавающей точкой
%e, %E Число с плавающей точкой и экспонентой в нижнем и верхнем регистре
%c Одиночный символ
%s, %r Строка из литерала и обычная
%% Символ процента

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

string = "text"
number = 10
newString = "this is {0} and digit {1}".format(string, number)
print(newString)

this is text and digit 10

В следующем примере показано как можно отцентрировать строку, воспользовавшись методом format и специальными символами. Изначальный текст здесь перемещается в самый центр строки, в то время как пустое пространство заполняется символом *.

string = "text"
newString = "{:*^10}".format(string)
print(newString)

***text***

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

Символ Назначение
‘<‘ Выравнивание строки по левому краю с символами-заполнителями справа
‘>’ Выравнивание строки по правому краю с символами-заполнителями слева
‘=’ Выравнивание с символами-заполнителями после знака числа, но перед его цифрами
‘^’ Выравнивание строки по центру с символами-заполнителями с обеих сторон
‘+’ Применение знака для любых чисел
‘-‘ Применение знака для отрицательных чисел и ничего для положительных
‘ ‘ Применение знака для отрицательных чисел и пробела для положительных

Операции над строками

Прежде чем перейти к функциям для работы со строками, следует рассмотреть основные операции с ними, которые позволяют быстро преобразовывать любые последовательности символов. При помощи знака плюс можно производить конкатенацию строк, соединяя их вместе. В следующем примере продемонстрировано объединение this is new и text.

string = "text"
newString = "this is new " + string
print(newString)

this is new text

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

string = "text "
newString = string * 3
print(newString)

text text text

Как и в случае с числами, со строками можно использовать операторы сравнения, например двойное равно. Очевидно, что литералы some text и some new text разные, поэтому вызов метода print выводит на экран булево значение False для строк string и newString.

string = "some text"
newString = "some new text"
print(string == newString)

False

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

string = "some text"
newString = string[2:4]
print(newString)

me

Отрицательный индекс позволяет обращаться к отдельным символами строки не с начала, а с конца. Таким образом, элемент под номером -2 в строке some text является буквой x.

string = "some text"
print(string[-2])

x

Методы и функции

Очень часто используется для приведения типов к строковому виду функция str. С ее помощью можно создать новую строку из литерала, который передается в качестве аргумента. Данный пример демонстрирует инициализацию переменной string новым значением some text.

string = str("some text")
print(string)

some text

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

В Python получения длины строки в символах используется функция len. Как видно из следующего фрагмента кода, длина объекта some text равняется 9 (пробелы тоже считаются).

string = "some text"
print(len(string))

9

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

string = "some text"
print(string.find("text"))

5

Метод replace служит для замены определенных символов или подстрок на введенную программистом последовательность символов. Для этого необходимо передать функции соответствующие аргументы, как в следующем примере, где пробелы заменяются на символ ‘-‘.

string = "some text"
print(string.replace(" ", "-"))

some-text

Для того чтобы разделить строку на несколько подстрок при помощи указанного разделителя, следует вызвать метод split. По умолчанию его разделителем является пробел. Как показано в приведенном ниже примере, some new text трансформируется в список строк strings.

string = "some new text"
strings = string.split()
print(strings)

['some', 'new', 'text']

Выполнить обратное преобразование, превратив список строк в одну можно при помощи метода join. В следующем примере в качестве разделителя для новой строки был указан пробел, а аргументом выступил массив strings, включающий some, new и text.

strings = ["some", "new", "text"]
string = " ".join(strings)
print(string)

some new text

Наконец, метод strip используется для автоматического удаления пробелов с обеих сторон строки, как это показано в следующем фрагменте кода для значения объекта string.

string = "   some new text   "
newString = string.strip()
print(newString)

some new text

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

Метод Назначение
str(obj) Преобразует объект к строковому виду
len(s) Возвращает длину строки
find(s, start, end), rfind(s, start, end) Возвращает индекс первого и последнего вхождения подстроки в s или -1, при этом поиск идет в границах от start до end
replace(s, ns) Меняет выбранную последовательность символов в s на новую подстроку ns
split(c) Разбивает на подстроки при помощи выбранного разделителя c
join(c) Объединяет список строк в одну при помощи выбранного разделителя c
strip(s), lstrip(s), rstrip(s) Убирает пробелы с обоих сторон s, только слева или только справа
center(num, c), ljust(num, c), rjust(num, c) Возвращает отцентрированную строку, выравненную по левому и по правому краю с длиной num и символом c по краям
lower(), upper() Перевод всех символов в нижний и верхний регистр
startwith(ns), endwith(ns) Проверяет, начинается ли или заканчивается строка подстрокой ns
islower(), isupper() Проверяет, состоит ли строка только из символов в нижнем и верхнем регистре
swapcase() Меняет регистр всех символов на противоположный
title() Переводит первую букву каждого слова в верхний регистр, а все остальные в нижний
capitalize() Переводит первую букву в верхний регистр, а все остальные в нижний
isalpha() Проверяет, состоит ли только из букв
isdigit() Проверяет, состоит ли только из цифр
isnumeric() Проверяет, является ли строка числом

Кодировка

Чтобы задать необходимую кодировку для используемых в строках символов в Python достаточно поместить соответствующую инструкцию в начало файла с кодом, как это было сделано в следующем примере, где используется utf-8. С помощью префикса u, который стоит перед литералом, можно помечать его соответствующей кодировкой. В то же время префикс b применяется для литералов строк с элементами величиной в один байт.

# coding: utf-8
string = u'some text'
newString = b'text'

Производить кодирование и декодирование отдельных строк с заданной кодировкой позволяют встроенные методы decode и encode. Аргументом для них является название кодировки, как в следующем примере кода, где применяется наименование utf-8.

string = string.decode('utf8')
newString = newString.encode('utf8')

используемые методы, функции и операторы, примеры кода

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

Например:

В этом руководстве мы узнаем:

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

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

О различных строковых операторах

Еще несколько примеров

О методе Python String replace()

Как приводить строки к верхнему и нижнему регистру

Об использование для строки функцию «join»

О реверсе строк

О разделении строк

Доступ к значениям в строках

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

var1 = «Guru99!» var2 = «Software Testing» print («var1[0]:»,var1[0]) print («var2[1:5]:»,var2[1:5])

var1 = «Guru99!»

var2 = «Software Testing»

print («var1[0]:»,var1[0])

print («var2[1:5]:»,var2[1:5])

Различные строковые операторы

Существуют различные строковые операторы, которые можно использовать по-разному, например, объединять строки. Предположим, что если a=guru, а b=99, то a+b= «guru99″. Точно так же, если вы используете *2, это будет «GuruGuru». Также вы можете использовать другие операторы.

Оператор []. Описание: Фрагмент — дает символ с данным индексом. Пример: a[1] дает «u» из слова Guru, так как (0=G, 1=u, 2=r и 3=u).

Оператор [:]. Описание: Диапазон фрагментов — дает символы из заданного диапазона. Пример: x[1:3] даем «ur» из слова гуру Guru. Помните, что это не учитывать 0, который является G, это будет учитывать буквы после него.

Оператор in. Описание: Содержит — возвращает true, если в заданной строке есть буква. Пример: u присутствует в слове Guru и, следовательно, это даст 1 (true).

Оператор not in. Описание: Не содержит -возвращает true, если буква не существует в данной строке. Пример: l не присутствует в слове Guru и, следовательно, это даст 1.

x=»Guru» print «l» not in x

x=»Guru»

print «l» not in x

Оператор r/R. Описание: Необработанная строка подавляет фактическое значение escape-символов. Пример: Напечатайте r’\n’ печатает \n и напечатайте R’\n’ печатает \n.

Оператор % — используется для формата строк. Описание: %r — вставляет каноническое строковое представление объекта (т. е. repr(o)), %s — вставляет строковое представление объекта (т. е. str(o)), %d — форматирует число для отображения. Пример: Вывод этого кода будет «guru 99″.

name = ‘guru’ number = 99 print’%s %d’ % (name,number)

name = ‘guru’

number = 99

print’%s %d’ % (name,number)

Оператор +. Описание: Объединение 2 строк. Пример: Объединяет строки и дает результат.

x=»Guru» y=»99″ print x+y

x=»Guru»

y=»99″

print x+y

Оператор *. Описание: Повторение. Пример: Выводит символ дважды.

x=»Guru» y=»99″ print x*2

x=»Guru»

y=»99″

print x*2

Еще несколько примеров

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

x = «Hello World!» print(x[:6]) print(x[0:6] + «Guru99»)

x = «Hello World!»

print(x[:6])

print(x[0:6] + «Guru99»)

Примечание: — Slice:6 или 0:6 дает тот же результат.

Метод строк Python replace()

Метод replace() возвращает копию строки, в которой значения старой строки были заменены новым значением.

oldstring = ‘I like Guru99’ newstring = oldstring.replace(‘like’, ‘love’) print(newstring)

oldstring = ‘I like Guru99’

newstring = oldstring.replace(‘like’, ‘love’)

print(newstring)

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Изменение верхнего и нижнего регистра строк

В Python вы можете даже привести строку к верхнему или нижнему регистру.

string=»python at guru99″ print(string.upper())

string=»python at guru99″

print(string.upper())

Кроме того, вы также можете использовать другую функцию, такую как capitalize:

string=»python at guru99″ print(string.capitalize())

string=»python at guru99″

print(string.capitalize())

Вы также можете преобразовать строку в нижний регистр:

string=»PYTHON AT GURU99″ print(string.lower())

string=»PYTHON AT GURU99″

print(string.lower())

Использование для строки функции «join»

Функция join является более гибким способом объединения строк. С помощью функции join вы можете добавить в строку любой символ.

Например, если вы хотите добавить двоеточие (:) после каждого символа в строке «Python», вы можете использовать следующий код.

print(«:».join(«Python»))

print(«:».join(«Python»))

Реверс строк

Используя функцию реверса, вы можете перевернуть строку. Например, если у нас есть строка «12345», а затем, если вы применяете код для обратной функции, как показано ниже.

string=»12345″ print(».join(reversed(string)))

string=»12345″

print(».join(reversed(string)))

Разделение строк

Разделение строк — это еще одна функция, которая может применяться в Python, давайте посмотрим на строку «guru99 career guru99″. Сначала мы разделим строку с помощью команды word.split и получим результат.

word=»guru99 career guru99″ print(word.split(‘ ‘))

word=»guru99 career guru99″

print(word.split(‘ ‘))

Чтобы лучше это понять, мы рассмотрим еще один пример разделения, вместо пробела (») мы используем (‘r’), и это будет разбивать строку везде, где в строке встречается ‘r’:

word=»guru99 career guru99″ print(word.split(‘r’))

word=»guru99 career guru99″

print(word.split(‘r’))

Важное примечание: В Python строки являются неизменяемыми. Рассмотрим следующий код:

x = «Guru99″ x.replace(«Guru99″,»Python») print(x)

x = «Guru99»

x.replace(«Guru99″,»Python»)

print(x)

все равно возвращает Guru99. Это связано с тем, что x.replace («Guru99″, «Python») возвращает копию X с выполненными заменами. Вам нужно будет использовать следующий код, чтобы увидеть изменения:

x = «Guru99″ x = x.replace(«Guru99″,»Python») print(x)

x = «Guru99»

x = x.replace(«Guru99″,»Python»)

print(x)

Приведенные выше коды являются примерами Python 3. Если вы хотите запустить Python 2, рассмотрите следующий код.

#Accessing Values in Strings var1 = «Guru99!» var2 = «Software Testing» print «var1[0]:»,var1[0] print «var2[1:5]:»,var2[1:5] #Some more examples x = «Hello World!» print x[:6] print x[0:6] + «Guru99″ #Python String replace() Method oldstring = ‘I like Guru99’ newstring = oldstring.replace(‘like’, ‘love’) print newstring #Changing upper and lower case strings string=»python at guru99″ print string.upper() string=»python at guru99″ print string.capitalize() string=»PYTHON AT GURU99″ print string.lower() #Using «join» function for the string print»:».join(«Python») #Reversing String string=»12345″ print».join(reversed(string)) #Split Strings word=»guru99 career guru99″ print word.split(‘ ‘) word=»guru99 career guru99″ print word.split(‘r’) x = «Guru99″ x.replace(«Guru99″,»Python») print x x = «Guru99″ x = x.replace(«Guru99″,»Python») print x

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

#Accessing Values in Strings

var1 = «Guru99!»

var2 = «Software Testing»

print «var1[0]:»,var1[0]

print «var2[1:5]:»,var2[1:5]

#Some more examples

x = «Hello World!»

print x[:6]

print x[0:6] + «Guru99»

#Python String replace() Method

oldstring = ‘I like Guru99’

newstring = oldstring.replace(‘like’, ‘love’)

print newstring

#Changing upper and lower case strings

string=»python at guru99″

print string.upper()

string=»python at guru99″

print string.capitalize()

string=»PYTHON AT GURU99″

print string.lower()

#Using «join» function for the string

print»:».join(«Python»)

#Reversing String

string=»12345″

print».join(reversed(string))

#Split Strings

word=»guru99 career guru99″

print word.split(‘ ‘)

word=»guru99 career guru99″

print word.split(‘r’)

x = «Guru99»

x.replace(«Guru99″,»Python»)

print x

x = «Guru99»

x = x.replace(«Guru99″,»Python»)

print x

В Python появилась функция .format, которая позволяет использовать %d и т. д. для форматирования строк.

Заключение

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

Доступ к значениям через разделение — квадратные скобки используются для нарезки вместе с индексом или индексами для получения подстроки.

В нарезке, если диапазон объявлен [1: 5], он может фактически извлечь значение из диапазона [1: 4]

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

Метод replace() возвращает копию строки, в которой вхождение старых символов заменяется новыми.

Синтаксис для метода replace: oldstring.replace(«значение, на которое заменяем», «значение, которое заменяем»)

Строковые операторы, такие как [], [:], in, Not in и т. д., могут применяться для конкатенации строки, извлечения или вставки определенных символов в строку или для проверки того, существует ли определенный символ в строке

Другие строковые операции включают:

Изменение верхнего и нижнего регистра

Функция Join, чтобы добавить любой символ в строку

Реверс строк

Разделение строк

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Введение в функции Python 3 для работы со строками

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

В этом руководстве мы рассмотрим несколько строковых функций в Python 3.

Функции str.upper() и str.lower() возвращают строку со всеми буквами исходной строки, преобразованными в прописные или строчные буквы. Символы в строке, которые не являются буквами, меняться не будут.

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

ss = "Sammy Shark"
print(ss.upper())

Вывод:

 

Теперь преобразуем эту же строку в нижний регистр:

Вывод:

 

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

 

В Python есть несколько методов, которые оценивают логический тип значения. Они применяются для валидации полей форм регистрации. Если мы запрашиваем почтовый индекс, то поле должно «принимать» только числовую строку. Но когда пользователь вводит имя, строка должна состоять только из букв.

Существует ряд строковых методов, которые возвращают логические значения:

МетодTrue если
str.isalnum()Строка состоит только из буквенно-цифровых символов (без специальных символов).
str.isalpha()Строка состоит только из буквенных символов (без специальных символов).
str.islower()Все буквенные символы строки имеют нижний регистр.
str.isnumeric()Строка состоит только из цифровых символов.
str.isspace()Строка состоит только из символов пробелов.
str.istitle()Строка заглавными буквами.
str.isupper()Все буквенные символы строки имеют верхний регистр.

Рассмотрим несколько методов в действии:

number = "5"
letters = "abcdef"

print(number.isnumeric())
print(letters.isnumeric())
Вывод:
True
False

Метод str.isnumeric() возвращает для строки number = «5» значение True, а тот же метод для строки letters = «abcdef» возвращает значение False.

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

Создадим несколько строк:

movie = "2001: A SAMMY ODYSSEY"
book = "A Thousand Splendid Sharks"
poem = "sammy lived in a pretty how town"

Теперь применим логические методы, которые проверяют регистр:

print(movie.islower())
print(movie.isupper())
print(book.istitle())
print(book.isupper())
print(poem.istitle())
print(poem.islower())

Выполним код и посмотрим на результат:

Вывод для строки movie:

Вывод для строки book:

 

Вывод для строки poem:

 

Проверка регистра строки позволяет правильно отсортировать данные. Логические методы также полезны для валидации полей форм на сайте.

Метод  len() возвращает количество символов в строке. Его можно использовать в тех случаях, когда необходимо установить минимальную или максимальную длину пароля. А также, если необходимо усечь длинные строки.

Чтобы продемонстрировать этот метод в действии, найдем длину предложения:

open_source = "Sammy contributes to open source."
print(len(open_source))

Вывод:

 

Мы инициализируем переменную open_source строковым значением «Sammy contributes to open source.». Затем передаем эту переменную в метод len() с помощью len(open_source). После этого используем  print() для вывода результата на экран.

Помните, что любой символ, заключенный в одинарные или двойные кавычки, будет учитываться методом len().

Метод str.join() объединяет две строки и разделяет их указанным символом.

Давайте создадим строку:

balloon = "Sammy has a balloon."

Теперь воспользуемся методом str.join(), чтобы добавить пробел к этой строке. Мы можем сделать так:

Если мы выведем это:

то увидим, что в новой возвращаемой строке добавлены пробелы между символами правой части строки.

Вывод:

S a m m y   h a s   a   b a l l o o n .

Мы также можем использовать метод str.join() для возврата строки, которая является перевернутой исходной строкой:

print("".join(reversed(balloon)))

Вывод:

 

Метод str.join() также полезен для объединения списка строк в новую единственную строку.

Создадим разделенную запятыми строку из списка строк:

print(",".join(["sharks", "crustaceans", "plankton"]))

Вывод:

 

sharks,crustaceans,plankton

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

 

".join(["sharks", "crustaceans", "plankton"]).

Также можно и разбивать строки. Для этого используется метод str.split():

Вывод:

['Sammy', 'has', 'a', 'balloon.']

Метод str.split() возвращает список строк, разделенных пробелами, если никакой другой параметр не задан.

Также можно использовать str.split() для удаления определенных частей строки. Например, давайте удалим из строки букву a:

print(balloon.split("a"))

Вывод:

['S', 'mmy h', 's ', ' b', 'lloon.']

Теперь буква a удалена, и строки разделены там, где она располагалась.

Метод str.replace() применять для замены части строки. Допустим, что  шарик, который был у Сэмми, потерян. Поскольку у Сэмми больше нет этого шарика, изменим подстроку «has» на новую строку «had»:

print(balloon.replace("has","had"))

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

Вывод:

Методы str.join(), str.split() и str.replace() позволяют более эффективно управлять строками в Python.

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

 

 

Данная публикация представляет собой перевод статьи «An Introduction to String Functions in Python 3» , подготовленной дружной командой проекта Интернет-технологии.ру

телеграм канал. Подпишись, будет полезно!

Строки | Python

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

>>> for x in range(0, 200, 20):
...     F_x = x**2/(x + 1)
...     G_x = (-1)**x*F_x**0.5 - 1
...     s = '| x = {0:<3} | F(x) = {1:<6.2f} | G(F(x)) = {2:<+8.4f} |'
...     print(s.format(x, F_x, G_x))
... 
| x = 0   | F(x) = 0.00   | G(F(x)) = -1.0000  |
| x = 20  | F(x) = 19.05  | G(F(x)) = +3.3644  |
| x = 40  | F(x) = 39.02  | G(F(x)) = +5.2470  |
| x = 60  | F(x) = 59.02  | G(F(x)) = +6.6822  |
| x = 80  | F(x) = 79.01  | G(F(x)) = +7.8889  |
| x = 100 | F(x) = 99.01  | G(F(x)) = +8.9504  |
| x = 120 | F(x) = 119.01 | G(F(x)) = +9.9091  |
| x = 140 | F(x) = 139.01 | G(F(x)) = +10.7901 |
| x = 160 | F(x) = 159.01 | G(F(x)) = +11.6098 |
| x = 180 | F(x) = 179.01 | G(F(x)) = +12.3793 |

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

Наверняка, вам придется строить различные графики, и, вероятнее всего, вам захочется что бы графики сопровождали красивые математические формулы. Тогда вам придется познакомиться с LaTeX и «сырыми» строками Python, что бы добавлять их:

import numpy as np, matplotlib.pyplot as plt
plt.hist(np.random.beta(70, 8, 100000), bins = 'fd')
title = r'$f_{X}(x)={\frac{1}{\mathrm{B}(\alpha,\beta)}}\,x^{\alpha-1}(1-x)^{\beta-1}$'
plt.title(title, fontsize = 20, pad = 20)
plt.show()


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

На самом деле, работа с текстом, точнее компьютерная обработка текста на натуральном человеческом языке – это очень удивительная штука, хотя бы потому что, лишь одной лингвистики в этом деле недостаточно. Вам потребуется знание линейной алгебры, теории графов, теории вероятности и математической статистики, теории множеств и других математических разделов. Я считаю, что это как минимум любопытно (хотя на самом деле я считаю, что это очень интересно).

Учитывая перспективы, которые нам открывает работа с текстом и язык Python, который будет нашим инструментом в этом деле, давайте для начала разберемся с типом данных str. Этот тип позволяет представить любой текст (и не только текст) в виде строк. Так что же такое строки?

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

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

Строки — это встроенные объекты. Это означает, что строки являются неотъемлемой частью языка и в этом нет ничего удивительного. Однако, они являются объектами и вот это уже любопытно. И вот почему – в языке Python, в контексте объектно ориентированного программирования, объектами является абсолтно все, т.е. мы не просто можем использовать типы данных, а еще и переопределять их и даже перегружать операторы для работы с ними. Далее вы узнаете, что строки поддерживают операторы «+» (конкатенация) и «*» (повторение). Однако, мы можем придумать для них и другие операторы, например «%» остаток от деления строки на равное количество подстрок. Звучит как бред конечно, но в каждом бреде есть доля реальности, а в каждой реальности есть доля бреда… парадокс… мда. Что там дальше?

Строки создаются с помощью строковых литералов. Благодаря этим литералам Python, собственно и понимает, что перед ним находится объект-строка. Вот несколько примеров создания строк:

>>> s = "Привет мир!!!"
>>> 
>>> s = """Привет мир!!!"""    #  а можно создать и так
>>> 
>>> s = 'Привет мир!!!'        #  но чаще всего вот так

Немного лукавя (строковым литералам посвящена целая страница, где нет никакого лукавства, см. Литералы строк), можно сказать, что апострофы и кавычки – это и есть литералы строк. В самом деле, возьмем число 321321, поместим его в апострофы и уже получим строку '321321'. А убедиться в этом мы можем с помощью встроенной функции type():

>>> type(321321)
<class 'int'>
>>> 
>>> type('321321')
<class 'str'>

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

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

>>> s[5]    #  индекс символа относительно начала строки
'т'
>>> s[-8]    #  индекс того же символа относительно конца строки
'т'

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

>>> s[7] = 'М'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

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

Хорошо, команда s[7] = 'М' не сработала. Однако, 'М' – что это, строка или отдельный символ? На самом деле 'М' – строка, в Python нет специального типа данных для отдельных символов. Поэтому строки из нескольких символов можно рассматривать, как последовательность строк единичной длины, которые получились в результате их конкатенации («склеивания»):

>>> 'М' + 'и' + 'р'
'Мир'

Конкатенация, вполне уместно, обозначается символом «+«, но строки можно еще и «умножать», т.е. повторять заданное количество раз:

>>> 'Мир!!!' * 7
'Мир!!!Мир!!!Мир!!!Мир!!!Мир!!!Мир!!!Мир!!!'

Строковые функции, методы и операторы

Строки являются последовательностями, а последовательности в языке Python образуют целый класс типов данных, который объединяет наличие общих свойств, а следовательно, общих функций и операторов. Например списки – это последовательности объектов, доступ к которым так же осуществляется по их индексу:

>>> s = 'Hello World!!!'    #  строка
>>> l = [1, 'a', 2.48, 'b']     #  список
>>> 
>>> s[1]
'e'
>>> l[1]
'a'

Списки, так же как и строки могут «складываться» (соединяться) и «умножаться» (дублироваться):

>>> l + l
[1, 'a', 2.48, 'b', 1, 'a', 2.48, 'b']
>>> 
>>> l*3
[1, 'a', 2.48, 'b', 1, 'a', 2.48, 'b', 1, 'a', 2.48, 'b']

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

>>> len(s), len(l)
(14, 4)

Операторы in и not in позволяют выяснить наличие или отсутствие в последовательности некоторого элемента:

>>> 'D' in 'ABCD'
True
>>> 'F' not in 'ABCD'
True
>>> 
>>> 1 in [1, 2, 3]
True
>>> 4 not in [1, 2, 3]
True

С помощью оператора in можно осуществлять перебор всех элементов любой последовательности в цикле for:

>>> for i in 'abcd':    #  поочередно перебираем каждый символ строки
...     print(i.capitalize())     #  и печатаем его в верхнем регистре
... 
A
B
C
D
>>> 
>>> for i in [1, 1.5, 2, 2.5]:    #  поочередно перебираем каждый элемент списка
...     print(i**2)     #  и печатаем его квадрат
... 
1
2.25
4
6.25

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

>>> 'ABCABCABC'.replace('AB', '@')    #  замена подстрок по шаблону
'@[email protected]@C'
>>> 
>>> 'AA AB AC AD AD AD'.find('AD')    #  индекс первого вхождения
9
>>> 
>>> 'AbCdEfG'.lower()    # все символы в нижнем регистре
'abcdefg'
>>> 
>>> 'AbCdEfG'.upper()    # все символы в верхнем регистре
'ABCDEFG'
>>> 
>>> '1,2.48,1 - 1j'.split(',')    #  разбить в список по разделителю ','
['1', '2.48', '1 - 1j']
>>> 
>>> ','.join(['1', '2.48', '1 - 1j'])    #  собрать из списка по разделителю ','
'1,2.48,1 - 1j'

Что бы посмотреть на список всех доступных строкам функций и методов достаточно передать функции dir() какой-нибудь строковый объект:

>>> import pprint    #  модуль для "красивой печати"
>>> 
>>> #  Сделаем вывод длинющего списка компактным:
... pprint.pprint(dir('s'), compact = True)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__',
 '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
 '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__',
 '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
 '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__',
 '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold',
 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format',
 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit',
 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle',
 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition',
 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip',
 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate',
 'upper', 'zfill']

Мы не спроста, воспользовались модулем pprint так как простая команда dir('s') привела бы к выводу длинного списка в виде одной длинной строки. Имейте ввиду, что данный модуль может оказаться очень полезным для организации удобочитаемого вывода данных и в некоторых ситуациях, гораздо проще воспользоваться именно им, чем ломать голову над форматированием строки для удобочитаемого вывода.


Кодировки

Другим любопытным моментом является то, что символы которые мы видим внутри строки на самом деле являются порядковыми номерами в таблице которая ставит в соответсвие этому номеру определенный сивол. Эти таблицы мы называем кодировками. Существует очень много кодировок, но возможно вы слышали названия некоторых из них: ASCII, Latin-1, КОИ-8, utf-8. По умолчанию, в Python используется стандарт «Юникод». И в том что каждому символу соответствует определенный код очень легко убедиться с помощью встроенных функций ord() и chr():

>>> ord('&')    # узнаем соответствующий символу код
38
>>> chr(38)    # узнаем соответствующий коду символ
'&'

Но к превеликому сожалению, это не только любопытно, но еще и очень печально. Представим себе, что наша программа должна обмениваться текстом с другой программой. Так как строки хранятся в виде байтов, то в нашу программу должна прилететь строка, которая может выглядеть, например, вот так b'\xcd\xc9\xd2'. Что же с ней делать?:

>>> s = b'\xcd\xc9\xd2'
>>> 
>>> str(s, encoding = 'utf-8')    #  попробуем преобразовать в Юникод
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xcd in position 0: invalid continuation byte

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

>>> str(s, encoding = 'cp866')    #  попробуем преобразовать в cp866
'═╔╥'

Какя-то абракадабра. Пробуем следующую:

>>> str(s, encoding = 'koi8_r')    #  удача
'мир'

Как видите, байтовые строки не несут информации о своей кодировке, хотя в зависимости от происхождения, эта кодировка может быть какой угодно. Рассмотренная проблема встречается очень редко, но все же встречается. Многие научные программы до сих пор используют кодировку ascii по умолчанию, а некоторые операционные системы могут использовать какую-то другую кодировку. Вообще, кодировкой по умолчанию является кодировка операционной системы (можно узнать с помощью функции getdefaultencoding() модуля sys). Так что, если вы создаете интернациональное приложение или сайт, или не знаете с какой операционкой придется работать вашей программе, то наверняка тоже встретитесь с этой проблемой. Повторюсь, проблема редкая, весьма специфичная и Python предоставляет относительно неплохие средства для ее преодоления.

Чтож, вот мы и познакомились со строками. Определение, которое мы дали в начале, могло показаться очень сложным и непонятным (я даже не совсем уверен в его правильности), но тем не менее, на деле, все оказалось довольно простым.


Строки байтов — bytes и bytearray

Определение которое мы дале в самом начале можно считать верным только для строк типа str. Но в Python имеется еще два дугих типа строк: bytes – неизменяемое строковое представление двоичных данных и bytearray – тоже что и bytes, только допускает непосредственное изменение.

Основное отличие типа str от bytes и bytearray заключается в том, что str всегда пытается превратить последовательность байтов в текст указанной кодировки. По умолчанию этой кодировкой является utf-8, но это очень большая кодировка и другие кодировки, например ASCII, Latin-1 и другие являются ее подмножествами. Одни символы кодируются одним байтом, другие двумя, а некоторые тремя и функция str() при декодировании последовательности байтов принимает это во внимание. А вот функциям bytes() и bytearray() до этого нет дела, для них абсолютно все данные состоят только из последовательности одиночных байтов.

Такое поведение bytes и bytearray очень удобно, если вы работаете с изображениями, аудиофайлами или сетевым трафиком. В этом случае, вам следует знать, что ничего магического в этих типах нет, они поддерживоют все теже строковые методы, операции индексирования, а так же операторы и функции для работы с последовательностями. Единственное, что следует держать в уме, так это то, что вы имеете дело с последовательностью байтов, т.е. последовательностью чисел из интервала [0; 255] в шестнадцатеричном представлении, и что байтовые строки отличаются от обычных символом b (режеB) предваряющим все литералы обычных строк.

Например, что бы создать строку типа bytes или bytearray достаточно передать соответствующим функциям последовательности целых чисел:

>>> a = bytes([1, 2, 3])
>>> a
b'\x01\x02\x03'
>>> 
>>> 
>>> b = bytearray([1, 2, 3])
>>> b
bytearray(b'\x01\x02\x03')

Учитывая то, что для кодирования некоторых символов (например ASCII) достаточно всего одного байта, данные типы пытаются представить последовательности в виде символов если это возможно. Например, строка '\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\x21' будет выведена как b'hello world!':

>>> b'\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\x21'
b'hello world!'

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

>>> a = b'aA1cZ22.sD'
>>> a
b'aA1cZ22.sD'

Но, следует помнить что это все-таки байты, в чем легко убедиться, если мы обратимся к какому-нибудь символу по его индексу в строке:

>>> a[4]
90

Так как строковые методы не изменяют сам объект, а создают новый, то при работе с очень длинными строками (а в мире двоичных данных это далеко не редкость) это может привести к большому расходу памяти. Собственно, по этой причине и существует тип bytearray, который позволяет менять байты прямо внутри строки:

>>> s = bytearray(b'hello world')
>>> s
bytearray(b'hello world')
>>> 
>>> s[0] = 72           #  код символа 'H'
>>> s[6] = ord('W')     #  функция ord() возвращает код нужного символа
>>> 
>>> s
bytearray(b'Hello World')

Python 3 — Строки | ИТ Блог. Администрирование серверов на основе Linux (Ubuntu, Debian, CentOS, openSUSE)

Строки являются одними из самых популярных типов в 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.

Основы Python — кратко. Строки. / Хабр

Поскольку число положительных отзывов превысило число отрицательных, продолжу выкладывание уроков. Те кто уже знаком с основами — можете или просто пропустить урок, или попробовать сделать задание 3 самым коротким способом 🙂

Для начала маленькое замечание.

Начиная с Python 2.3, всем, кто использует не-ASCII кодировку нужно добавлять указание о кодировке в самом начале программы. Для русского языка это будет в основном:

# -*- coding: cp1251 -*-

или использовать для хранения исходных текстов файлы utf-8 (что предпочтительней).

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

Строки


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

>>> "habrahabr"
'habrahabr'
>>> 'foo bar boz'
'foo bar boz'
>>> "won't"
"won't"
>>> 'don"t'
'don"t'
>>> "couldn\"t"
'couldn"t'
>>> """multi line
... very long
... string constant"""
'multi line\nvery long\nstring constant'
>>> 'this takes \
... two lines'
'this takes two lines'

Строки можно склеивать оператором + и «размножать» оператором *
>>> "Hello "+"word"
'Hello word'
>>> "Hello "*3
'Hello Hello Hello '

По сути же своей строка представляет собой последовательность символов с произвольным доступом. Для получения части символов строки можно использовать т.н. оператор «среза». Обратите внимание, что нумерация начитается с нуля (и достаточно хаотична на первый взгляд).
>>> str = "Hello, cruel world!"
# получить 4 символ строки
>>> str[3] 
'l'
# все символы с 8 по 14
>>> str[7:14]
'cruel w'
# каждый второй символ со 2 по 13
>>> str[1:12:2]
'el,cul'
# некоторые значения можно опускать
# каждый второй символ строки.
>>> str[::2]
'Hlo re ol!'

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

# первые 2 символа строки
>>> str[:2]
'He'
# вся строка кроме 2 первых символов
>>> str[2:]
'llo, cruel world!'

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

Также срезы могут принимать отрицательные значения.


# последний символ
>>> str[-1]
'!' 
# второй символ с конца
>>> str[-2]
'd'
# два последних символа
>>> str[-2:]
'd!'
# все символы кроме последних двух
>>> str[:-2]
'Hello, cruel worl'

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

Для определения длины строки используется функция len().

Unicode

В последних версиях Пайтон очень хорошо поддерживается работа с Unicode-строками.

Для задания unicode-строки в виде константы используется префикс u.

>>> uni = u"Тест"
>>> uni
u'\u0422\u0435\u0441\u0442'

Кроме того, Пайтон позволяет создать строку в Unicode с помощью одноименной функции.
>>> uni = unicode("Тест", "UTF-8")
>>> uni
u'\u0422\u0435\u0441\u0442'

Эта функция функция может работать с Latin-1, ASCII, UTF-8, UTF-16, с русскими кодировками ISO-8859-5, KOI8-R, CP1251, CP866 и Mac-cyrillic, и многими другими.

Для обратного преобразования служит метод encode, который преобразует unicode-строку в строку с заданной кодировкой.

>>> uni.encode("UTF-8")
'\xd0\xa2\xd0\xb5\xd1\x81\xd1\x82'
>>> uni.encode("CP1251")
'\xd2\xe5\xf1\xf2'

Для преобразования строки в список по определенному разделителю, используется метод split.
Этот метод в качестве параметра запрашивает разделитель, а возвращает список отдельных «слов» по которому можно «пройти» в цикле for.
>>> str = "Mary has a little lamb"
>>> str.split(" ")
['Mary', 'has', 'a', 'little', 'lamb']
>>> for word in str.split(" "):
...     print word
...
Mary
has
a
little
lamb

Домашнее задание.

1. Написать программу, выводящую заданную пользователем строку как минимум в 3 разных кодировках. При этом писать вызов метода encode() в программе можно только 1 раз.
2. Написать программу поиска самого длинного слова в строке, разделенной пробелами.
3. (Повышенная сложность) Написать программу декодирования телефонного номера для АОН.
По запросу АОНа АТС посылает телефонный номер, используя следующие правила:
— Если цифра повторяется менее 2 раз, то это помеха и она должна быть отброшена
— Каждая значащая цифра повторяется минимум 2 раза
— Если в номере идут несколько цифр подряд, то для обозначения «такая же цифра как предыдущая» используется идущий 2 или более подряд раз знак #

Например, входящая строка 4434###552222311333661 соответствует номеру 4452136
Кстати, регулярные выражения использовать в этих заданиях — нельзя 🙂

Python 3-строковые методы

Метод Описание Примеры
капитализировать ()

Возвращает копию строки, в которой первый символ в верхнем регистре, а остальные в нижнем.

Используйте title () , если вы хотите, чтобы первый символ всех слов был заглавным (т.е. регистр заголовка).

a = «пчелиный укус» печать (a.capitalize ())

Результат

  Укус пчелы  
кожух () Возвращает копию строки в развернутом виде. Строки с регистром могут использоваться для сопоставления без регистра. a = «BEE» print (a.casefold ())

Результат

  пчела  
центр ( ширина [, fillchar ]) Возвращает строку с центром в строке длиной шириной .Заполнение может быть выполнено с помощью указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s) a = «пчела» b = a.center (12, «-«) print (b)

Результат

  ---- пчела -----  
счетчик ( суб [, начало [, конец ]])

Возвращает количество неперекрывающихся вхождений подстроки ( подстроки ) в диапазоне [ начало , конец ].Необязательные аргументы начало и конец интерпретируются как в нотации среза.

Неперекрывающиеся вхождения означает, что Python не будет дублировать символы, которые уже были подсчитаны. Например, использование подстроки xxx против xxxx возвращает 1 .

a = «Шашлычный суп» print (a.count («O»)) print (a.count («o»)) print (a.count («oo»)) печать (a.счет («ооо»)) print (a.count («Гомер»)) print (a.count («o», 4, 7)) print (a.count («o», 7))

Результат

  0
5
2
1
0
2
3  
кодировать (encoding = "utf-8", errors = "strict")

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

  • strict (ошибки кодирования вызывают UnicodeError )
  • игнорировать
  • заменить
  • xmlcharrefreplace
  • обратная косая черта заменить
  • любое другое имя, зарегистрированное с помощью codecs.register_error ()
из base64 импортировать b64encode a = «Банан» печать (а) a = b64encode (a.кодировать ()) print (a)

Результат

  банан
b'QmFuYW5h ' 
заканчивается на ( суффикс [, начало [, конец ]])

Возвращает Истина , если строка заканчивается указанным суффиксом, в противном случае возвращает Ложь . суффикс также может быть кортежем суффиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции.С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Банан» print (a.endswith («a»)) print (a.endswith («нана»)) print (a.endswith («z»)) print (a.endswith («an», 1, 3))

Результат

  Верно
Правда
Ложь
Правда  
expandtabs (tabsize = 8)

Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции.Позиции табуляции появляются для каждого символа табуляции (по умолчанию 8 , что дает позиции табуляции в столбцах 0, 8, 16 и так далее).

а = «1 \ t2 \ t3» печать (а) печать (a.expandtabs ()) печать (a.expandtabs (tabsize = 12)) print (a.expandtabs (tabsize = 2))

Результат

  1 2 3
1 2 3
1 2 3
1 2 3  
find ( sub [, start [, end ]])

Возвращает наименьший индекс в строке, где подстрока sub находится в пределах фрагмента s [начало: конец] .Необязательные аргументы начало и конец интерпретируются как в нотации среза. Возвращает -1 , если sub не найден.

Метод find () следует использовать только в том случае, если вам нужно знать позицию подстроки. Если вам не нужно знать его позицию (т.е. вам нужно только знать, существует ли подстрока в строке), используйте оператор in . См. Строковые операторы для примера в .

a = «Фитнес» print (a.find («F»)) print (a.find («f»)) print (a.find («n»)) print (a.find («сущность»)) print (a.find («ess»)) print (a.find («z»)) print (a.find («Homer»))

Результат

  0
-1
3
3
4
-1
-1  
формат (* args , ** kwargs )

Выполняет операцию форматирования строки.Строка, для которой вызывается этот метод, может содержать буквальный текст или поля замены, разделенные фигурными скобками {} . Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя аргумента ключевого слова. Возвращает копию строки, в которой каждое поле замены заменяется строковым значением соответствующего аргумента.

# Пример 1 print («{} и {}».формат («Чай», «Кофе»)) # Пример 2 print («{1} и {0}». format («Чай», «Кофе»)) # Пример 3 print («{обед} и {ужин}». format (обед = «Горошек», ужин = «Фасоль»)) # Пример 4 print («{0}, {1}, {2}». format (* «123»)) # Пример 5 обед = {«food»: «Пицца», «drink»: «Вино»} print («Обед: {еда}, {напиток}». format (** обед))

Результат

  Чай и кофе
Кофе и чай
Горох и фасоль
1, 2, 3
Обед: пицца, вино  
format_map ( отображение )

Аналогичен формату (** отображение) , за исключением того, что отображение используется напрямую и не копируется в словарь.Это полезно, если, например, отображение является подклассом dict.

# Пример 1 обед = {«Еда»: «Пицца», «Напиток»: «Вино»} print («Обед: {Еда}, {Напиток}». format_map (Обед)) # Пример 2 класс по умолчанию (dict): def __missing __ (я, ключ): ключ возврата обед = {«Еда»: «Пицца»} print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед))) обед = {«Напиток»: «Вино»} print («Обед: {Еда}, {Напиток}». format_map (По умолчанию (обед)))

Результат

  Обед: пицца, вино
Обед: пицца, напитки
Обед: еда, вино  
индекс ( sub [, начало [, конец ]])

Подобно find () (выше), но вызывает ValueError , когда подстрока не найдена ( find () возвращает -1 , если подстрока не найдена).

a = «Фитнес» print (a.index («F»)) print (a.index («n»)) print (a.index («сущность»)) print (a.index («ess»)) print (a.index («z»)) #Error

Результат

  0
3
3
4
ValueError: подстрока не найдена  
isalnum ()

Возвращает Истина , если все символы в строке буквенно-цифровые и есть хотя бы один символ.В противном случае возвращает False .

Символ c считается буквенно-цифровым, если одно из следующих значений возвращает True :

  • c.isalpha ()
  • c.isdecimal ()
  • c.isdigit ()
  • c. Числовой ()
c = «Фитнес» печать (c.isalnum ()) c = «123» печать (c.isalnum ()) c = «1,23» печать (c.isalnum ()) c = «$ *% !!!» печать (c.isalnum ()) c = «0,34j» print (c.isalnum ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь  
isalpha ()

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

Обратите внимание, что «алфавитными» в данном случае являются те символы, которые определены в базе данных символов Unicode как «Letter». Это персонажи, общее свойство категории которых может быть одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Это отличается от свойства «Alphabetic», определенного в стандарте Unicode.

c = «Фитнес» печать (c.isalpha ()) c = «123» печать (c.isalpha ()) c = «$ *% !!!» print (c.isalpha ())

Результат

  Верно
Ложь
Ложь  
десятичное ()

Возвращает Истина , если все символы в строке являются десятичными и имеется хотя бы один символ.В противном случае возвращает False .

Десятичные символы — это те, которые могут использоваться для образования чисел с основанием 10. Десятичные символы — это символы из общей категории Unicode «Nd».

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123» печать (c.isdecimal ()) c = u «\ u00B2» печать (c.isdecimal ()) c = «1,23» печать (c.isdecimal ()) c = «u123» печать (c.isdecimal ()) c = «Фитнес» печать (c.isdecimal ()) c = «$ *% !!!» print (c.isdecimal ())

Результат

  Верно
Ложь
Ложь
Ложь
Ложь
Ложь  
isdigit ()

Возвращает Истина , если все символы в строке являются цифрами и имеется хотя бы один символ. В противном случае возвращает False .

Метод isdigit () часто используется при работе с различными символами Юникода, такими как надстрочные символы (например, 2 ).

Цифра — это символ, имеющий значение свойства Numeric_Type = Digit или Numeric_Type = Decimal .

Вы можете увидеть разницу между isdigit () и isdecimal () по тому, как они обрабатывают второй пример ( u "\ u00B2" ).

c = «123» печать (c.isdigit ()) c = u «\ u00B2» печать (c.isdigit ()) c = «1,23» печать (c.isdigit ()) c = «u123» печать (c.isdigit ()) c = «Фитнес» печать (c.isdigit ()) c = «$ *% !!!» print (c.isdigit ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь
Ложь  
isidentifier ()

Возвращает истину, если строка является допустимым идентификатором в соответствии с определением языка, разделом «Идентификаторы» и ключевыми словами из документации Python.

Используйте keyword.iskeyword () для проверки зарезервированных идентификаторов, таких как def , для и class .

а = «123» печать (a.isidentifier ()) a = «_user_123» печать (a.isidentifier ()) a = «_user-123» печать (a.isidentifier ()) a = «Гомер» печать (a.isidentifier ()) a = «для» print (a.isidentifier ())

Результат

  Ложь
Правда
Ложь
Правда
Правда  
нижний ()

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

Символы в регистре — это символы, общее свойство категории которых является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

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

а = «» печать (a.islower ()) а = «123» печать (a.islower ()) a = «_user_123» печать (a.islower ()) a = «Гомер» печать (a.islower ()) a = «HOMER» печать (a.islower ()) а = «гомер» печать (a.islower ()) a = «HOMER» a = a.casefold () # Принудительно использовать строчные буквы print (a.islower ())

Результат

  Ложь
Ложь
Правда
Ложь
Ложь
Правда
Правда  
числовой ()

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

Числовые символы включают цифровые символы и все символы, которые имеют свойство числового значения Unicode. Числовые символы — это символы со значением свойства Numeric_Type = Digit , Numeric_Type = Decimal или Numeric_Type = Numeric .

c = «123» печать (c.isnumeric ()) c = u «\ u00B2» печать (c.isnumeric ()) c = «1,23» печать (c.isnumeric ()) c = «u123» печать (c.isnumeric ()) c = «Фитнес» печать (c.isnumeric ()) c = «$ *% !!!» print (c.isnumeric ())

Результат

  Верно
Правда
Ложь
Ложь
Ложь
Ложь  
для печати ()

Возвращает Истина , если все символы в строке печатаются или строка пуста. В противном случае возвращает False .

Непечатаемые символы — это те символы, которые определены в базе данных символов Unicode как «Другой» или «Разделитель», за исключением пробела ASCII ( 0x20 ), который считается печатаемым.

Печатные символы в этом контексте — это те, которые не следует экранировать, когда repr () вызывается для строки. Он не имеет отношения к обработке строк, записанных в sys.stdout или sys.stderr .

а = «» печать (a.isprintable ()) а = «» печать (a.isprintable ()) a = u «\ u00B2» печать (a.isprintable ()) a = «Барт» печать (a.isprintable ()) а = «\ т» печать (a.isprintable ()) a = «\ r \ n» печать (a.isprintable ()) a = «Барт \ r» print (a.isprintable ())

Результат

  Верно
Правда
Правда
Правда
Ложь
Ложь
Ложь  
isspace ()

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

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также те, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «» печать (a.isspace ()) а = «» печать (a.isspace ()) a = «Барт» печать (a.isspace ()) а = «\ т» печать (a.isspace ()) a = «\ r \ n» печать (a.isspace ()) a = «Барт \ r» print (a.isspace ())

Результат

  Ложь
Правда
Ложь
Правда
Правда
Ложь  
название ()

Возвращает Истина. , если строка является строкой с заглавными буквами и содержит хотя бы один символ (например, символы верхнего регистра могут следовать только за символами без регистра, а символы нижнего регистра — только за ними).В противном случае возвращает False .

Пробельные символы — это те символы, которые определены в базе данных символов Юникода как «Другой» или «Разделитель», а также те, для которых свойство двунаправленности является одним из «WS», «B» или «S».

а = «» печать (a.istitle ()) а = «» print (a.istitle ()) а = «т» print (a.istitle ()) а = «Т» print (a.istitle ()) a = «Чай» print (a.istitle ()) a = «Чай и кофе» печать (a.istitle ()) a = «Чай и кофе» печать (a.istitle ()) a = «1. Чай и кофе \ r» print (a.istitle ())

Результат

  Ложь
Ложь
Ложь
Правда
Правда
Ложь
Правда
Правда  
верхний ()

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

Символы в регистре — это символы, общее свойство категории которых является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, регистр заголовка).

а = «» печать (a.isupper ()) а = «123» печать (a.isupper ()) a = «_USER_123» печать (a.isupper ()) a = «Гомер» печать (a.isupper ()) a = «HOMER» печать (a.isupper ()) а = «гомер» печать (a.isupper ()) a = «HOMER» a = a.casefold () # Принудительно использовать строчные буквы print (a.isupper ())

Результат

  Ложь
Ложь
Правда
Ложь
Правда
Ложь
Ложь  
соединение (итерация)

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

а = «-» print (a.join («123»)) a = «.» print (a.join («США»)) a = «.» print (a.join ((«Dr», «Who»)))

Результат

  1-2-3
США
Доктор Кто  
ljust ( ширина [, fillchar ]) Возвращает строку, выровненную по левому краю, в строке длиной и шириной .Заполнение может быть выполнено с помощью указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s) a = «пчела» b = a.ljust (12, «-«) print (b)

Результат

  пчела ---------  
нижний ()

Возвращает копию строки, в которой все символы в регистре преобразованы в нижний регистр.

casefold () — это более агрессивный метод перевода строки в нижний регистр, и он подходит для сопоставления регистра.

a = «BEE» print (a.lower ())

Результат

  пчела  
lstrip ([ chars ])

Вернуть копию строки с удаленными ведущими символами.Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение None , аргумент chars по умолчанию удаляет пробелы.

Обратите внимание, что аргумент chars не является префиксом — все комбинации его значений удаляются.

a = «Пчела» print (a.lstrip (), «!») a = «—— Пчела ——» print (a.lstrip («-«))

Результат

  Пчела!
Пчела -----  
maketrans ( x [, y [, z ]])

Это статический метод, который возвращает таблицу перевода, используемую для str.Переводчик () .

  • Если есть только один аргумент, это должен быть словарь, отображающий порядковые номера Unicode (целые числа) или символы (строки длиной 1) в порядковые номера Unicode, строки (произвольной длины) или установить значение None . После этого символьные ключи будут преобразованы в порядковые.
  • Если есть два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ в x будет сопоставлен с символом в той же позиции в y .
  • Если есть третий аргумент, это должна быть строка, символы которой будут сопоставлены с Нет в результате.
frm = «SecrtCod» to = «12345678» trans_table = str.maketrans (frm, to) secret_code = «Секретный код» .translate (trans_table) print (secret_code)

Результат

  123425 6782  
перегородка ( сен )

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

a = «Python-программа» print (a.partition («-«)) print (a.partition («.»))

Результат

  ('Python', '-', 'программа')
('Программа на Python', '', '')  
заменить ( старый , новый [, count ])

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

a = «Чайный пакетик. Чайная чашка. Чайные листья.» print (a.replace («Чай», «Кофе»)) print (a.replace («Чай», «Кофе», 2))

Результат

  Кофейный пакетик. Чашка кофе. Листья кофе.
Пакетик кофе. Чашка кофе. Чайные листья. 
rfind ( sub [, start [, end ]])

Возвращает наивысший индекс в строке, где найдена подстрока sub , так что sub содержится в пределах с [начало: конец] . Необязательные аргументы начало и конец интерпретируются как в нотации среза. Этот метод возвращает -1 в случае ошибки.

a = «Да, фитнес» print (a.rfind («Y»)) print (a.rfind («е»)) print (a.rfind («s»)) print (a.rfind («сс»)) print (a.rfind («y»)) print (a.rfind («z»)) print (a.rfind («Homer»))

Результат

  0
8
10
9
-1
-1
-1  
rindex ( sub [, start [, end ]])

Подобно rfind () , но вызывает ValueError , если подстрока sub не найдена.

a = «Да, фитнес» print (a.rindex («Y»)) print (a.rindex («e»)) print (a.rindex («s»)) print (a.rindex («ss»)) print (a.rindex («y»)) print (a.rindex («z»)) print (a.rindex («Homer»))

Результат

  0
8
10
9
ValueError: подстрока не найдена
ValueError: подстрока не найдена
ValueError: подстрока не найдена  
rjust ( ширина [, fillchar ]) Возвращает строку, выровненную по правому краю, в строке длиной и шириной .Заполнение может быть выполнено с помощью указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна лин (s) a = «пчела» b = a.rjust (12, «-«) print (b)

Результат

  --------- пчела  
r раздел ( sep )

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

a = «Гомер-Джей-Симпсон» print (a.rpartition («-«)) print (a.rpartition («.»))

Результат

  ('Гомер-Джей', '-', 'Симпсон')
('', '', 'Гомер-Джей-Симпсон')  
rsplit (sep = None, maxsplit = -1)

Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано maxsplit , выполняется не более maxsplit разбиений, крайних правых . Если sep не указано или установлено значение None , любая строка с пробелами является разделителем.

За исключением разделения справа, rsplit () ведет себя как split () , описанный ниже.

a = «Гомер Джей Симпсон» печать (a.rsplit ()) a = «Гомер-Джей-Симпсон» печать (a.rsplit (sep = «-«, maxsplit = 1))

Результат

  [«Гомер», «Джей», «Симпсон»]
[«Гомер-Джей», «Симпсон»]  
rstrip ([ chars ])

Вернуть копию строки с удаленными завершающими символами. Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение None , аргумент chars по умолчанию удаляет пробелы.

Обратите внимание, что аргумент chars не является суффиксом — все комбинации его значений удаляются.

a = «Пчела» print (a.rstrip (), «!») a = «—— Пчела ——» print (a.rstrip («-«))

Результат

  Пчела!
----- Пчела  
разделить (sep = None, maxsplit = -1)

Возвращает список слов в строке, используя sep в качестве строки-разделителя.Если задано maxsplit , будет выполнено не более maxsplit разбиений. Если maxsplit не указан или -1 , то количество разделений не ограничено.

Если задано sep , последовательные разделители не группируются вместе и считаются разделителями пустых строк (например, '1`` 2'.split (', ') возвращает [' 1 ',' ', '2'] ).

Аргумент sep может состоять из нескольких символов (например, '1 <> 2 <> 3'.split ('<>') возвращает ['1', '2', '3'] ). Разделение пустой строки указанным разделителем возвращает [''] .

Если sep не указано или установлено значение None , применяется другой алгоритм разделения: последовательности последовательных пробелов рассматриваются как один разделитель, и результат не будет содержать пустых строк в начале или в конце, если строка имеет начальные или конечные пробелы. Следовательно, разделение пустой строки или строки, состоящей только из пробелов, с помощью разделителя None возвращает значение [] .

a = «Гомер Джей Симпсон» печать (a.split ()) a = «Гомер-Джей-Симпсон» print (a.split (sep = «-«, maxsplit = 1)) a = «Гомер, Барт,» print (a.split («,»)) a = «Гомер ,, Барт» print (a.split («,», maxsplit = 1)) a = «Гомер <> Барт <> Мардж» print (a.split («<>«))

Результат

  [«Гомер», «Джей», «Симпсон»]
["Гомер", "Джей-Симпсон"]
['Гомер', '', 'Барт', '']
['Гомер', ', Барт']
["Гомер", "Барт", "Мардж"]  
Splitlines ([keepends])

Возвращает список строк в строке с разрывом по границам строки.Разрывы строк не включаются в результирующий список, если не указан keepends и его значение — True .

Этот метод разбивается на следующие границы строк.

Представительство Описание
\ п Перевод строки
\ r Возврат каретки
\ n \ r Возврат каретки + перевод строки
\ v или \ x0b Таблица строк
\ f или \ x0c Подача формы
\ x1c Разделитель файлов
\ x1d Групповой разделитель
\ x1e Разделитель записей
\ x85 Следующая строка (контрольный код C1)
\ u2028 Разделитель линий
\ u2029 Разделитель абзацев
a = «Чай \ n \ nи кофе \ rчашки \ r \ n» печать (a.splitlines ()) print (a.splitlines (keepends = True))

Результат

  ["Чай", "", "и кофе", "чашки"]
['Чай \ n', '\ n', 'и кофе \ r', 'чашки \ r \ n']  
начинается с (префикс [, начало [, конец ]])

Возвращает True , если строка начинается с указанного префикса, в противном случае возвращает False .Префикс также может быть кортежем префиксов. Если указан (необязательный) аргумент start , тест начинается с этой позиции. С опциональным и концом тест прекращает сравнение в этой позиции.

a = «Гомер» print (a.startswith («H»)) print (a.startswith («h»)) print (a.startswith («Гомер»)) print (a.startswith («z»)) print (a.startswith («om», 1, 3))

Результат

  Верно
Ложь
Правда
Ложь
Правда  
полоса ([ chars ])

Возвращает копию строки с удаленными начальными и конечными символами.Аргумент chars — это строка, определяющая набор символов, которые необходимо удалить. Если опущено или установлено значение None , аргумент chars по умолчанию удаляет пробелы.

Обратите внимание, что аргумент chars не является префиксом или суффиксом — все комбинации его значений удаляются.

a = «Пчела» print (a.strip (), «!») a = «—— Пчела ——» print (a.strip («-«))

Результат

  Пчела!
Пчела  
свопкейс ()

Возвращает копию строки, в которой символы верхнего регистра преобразованы в нижний регистр и наоборот.

Обратите внимание, что использование swapcase () дважды в строке не всегда возвращает ее к исходному состоянию. В некоторых случаях два разных символа нижнего регистра используют один символ верхнего регистра, поэтому замена регистра может иметь непреднамеренный эффект. См. Этот вопрос / ответ о переполнении стека для примеров.

a = «Гомер Симпсон» print (a.swapcase ())

Результат

  ГОМЕР СИМПСОН  
название ()

Возвращает версию строки в заглавном регистре.Регистр заголовка — это когда слова начинаются с символа верхнего регистра, а остальные символы — с нижнего регистра.

Используйте capitalize () , если вы хотите, чтобы первое слово было заглавным.

a = «чай и кофе» print (a.title ()) a = «ЧАЙ И КОФЕ» print (a.title ())

Результат

  Чай и кофе
Чай и кофе  
перевести ( таблица )

Возвращает копию строки, в которой каждый символ был отображен в данной таблице перевода.Таблица должна быть объектом, который реализует индексацию через __getitem __ () , обычно это отображение или последовательность.

Вы можете использовать maketrans () для создания карты преобразования из символьных отображений в различных форматах.

frm = «SecrtCod» to = «12345678» trans_table = str.maketrans (frm, to) secret_code = «Секретный код» .translate (trans_table) print (secret_code)

Результат

  123425 6782  
верх ()

Возвращает копию строки, в которой все символы в регистре преобразованы в верхний регистр.

a = «пчела» print (a.upper ())

Результат

  пчела  
zfill ( ширина )

Возвращает копию строки, заполненную слева цифрами ASCII 0 , чтобы сделать строку длиной шириной . Префикс ведущего знака ( + / - ) обрабатывается путем вставки отступа после символа знака, а не перед ним.Исходная строка возвращается, если ширина меньше или равна лин (s) .

а = «36» печать (a.zfill (5)) а = «-36» печать (a.zfill (5)) а = «+36» print (a.zfill (5))

Результат

  00036
-0036
+0036  
.

Python 3 Строковые операторы

Список строковых операторов, доступных в Python 3.

Оператор Описание Операция Пример
+ Объединяет (объединяет) строка1 и строка2 строка1 + строка2 a = «Чай» + «Лист» print (a)

Результат

  Чайный лист  
* Повторяет строку столько раз, сколько указано в x строка * x a = «Пчела» * 3 print (a)

Результат

  Пчела Пчела Пчела  
[] Slice — возвращает символ из указанного индекса с размером x . строка [x] a = «Море» print (a [1])

Результат

  e  
[:] Range Slice — возвращает символы из диапазона, указанного в x: y . строка [x: y] a = «Гриб» print (a [4: 8])

Результат

  комн.  
дюйм Membership — возвращает True , если в строке существует x .Может быть несколько символов. х в строке a = «Гриб» печать («м» в) print («b» в a) print («shroo» in a)

Результат

  Верно
Ложь
Правда  
кроме Membership — возвращает True , если x не не существует в строке. Может быть несколько символов. x не в строке a = «Гриб» print («m» не в a) print («b» не в a) print («shroo» не в a)

Результат

  Ложь
Правда
Ложь  
r Подавляет escape-последовательность ( \ x ), так что она фактически отображается. Другими словами, это предотвращает превращение escape-символа в escape-символ. r "\ x" a = «1» + «\ t» + «Пчела» b = «2» + r «\ t» + «Чай» печать (а) print (b)

Результат

  1 пчела
2 \ t Чай  
%

Выполняет форматирование строк. Его можно использовать в качестве заполнителя для другого значения, вставляемого в строку.Символ % является префиксом к другому символу ( x ), который определяет тип значения, которое нужно вставить. Вставляемое значение указывается в конце строки после другого символа % .

Знак Описание
% в Персонаж.
% s Преобразование строки с помощью str () перед форматированием.
% и Десятичное целое число со знаком.
% d Десятичное целое число со знаком.
% и Десятичное целое без знака.
% или Восьмеричное целое число.
% x Целое шестнадцатеричное число с использованием строчных букв.
% X Целое шестнадцатеричное число с прописными буквами.
% e Экспоненциальное представление с нижним регистром e .
% E Экспоненциальное представление с прописными буквами e .
% f Действительное число с плавающей запятой.
% г Короче % f и % e .
% G Короче % f и % E .
% x a = «Привет,% s»% («Гомер») print (a)

Результат

  Привет Гомер  
.Учебное пособие по строкам

Python — строковые функции с примерами

Здравствуйте, зрители, в этом посте мы исследуем мир Python Strings, часто используемых функций и некоторых важных функций. Строки в Python являются объектами, а Python предоставляет нет. встроенных / библиотечных функций для их изменения.

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

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

Давайте посмотрим на основные моменты текущего обсуждения.

Изучите основы строк Python

Как создавать строки в Python?

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

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

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

 # Примеры строк Python - все назначения идентичны.
String_var = 'Python'
String_var = "Python"
String_var = "" "Python" ""

# с тройными кавычками Строки могут расширяться до нескольких строк
String_var = "" "Этот документ поможет вам
изучить все концепции
строк Python !!! "" "

# Заменить «документ» на «учебник» и сохранить в другой переменной
substr_var = String_var.replace ("документ", "учебник")
печать (substr_var)
 

Строки индекса и среза в Python

Доступ к отдельным символам строки

Вам необходимо знать индекс символа, чтобы получить его из String.

Как и большинство языков программирования, Python позволяет индексировать с нулевой позиции в строках. Но он также поддерживает отрицательные индексы. Индекс «-1» представляет последний символ строки. Точно так же, используя «-2», мы можем получить доступ к предпоследнему элементу строки и так далее.

 sample_str = 'Строка Python'

print (sample_str [0]) # возвращает 1-й символ
# вывод: P

print (sample_str [-1]) # возвращает последний символ
# output: g

print (sample_str [-2]) # возвращает последний второй символ
# output: n
 
Разрезать строку в Python

Чтобы получить диапазон символов в строке, мы используем «оператор среза», знак двоеточия «:». С помощью оператора среза мы определяем диапазон как [a: b].Это позволит нам напечатать все символы String, начиная с индекса «a» и заканчивая символом с индексом «b-1». Таким образом, символ с индексом «b» не является частью вывода.

 sample_str = 'Строка Python'
print (sample_str [3: 5]) # возвращает диапазон символов
# хо
print (sample_str [7:]) # возвращает все символы из индекса 7
# String
print (sample_str [: 6]) # возвращает все символы до индекса 6
# Python
печать (sample_str [7: -4])
# St
 

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

Рекомендуемая литература:

ТОС

Python Strings — общие коды ошибок

1- Если мы попытаемся получить символы с индексом вне диапазона, то возникнет исключение «IndexError».

 sample_str = "Python поддерживает машинное обучение."
print (sample_str [1024]) #index должен быть в диапазоне

# IndexError: индекс строки вне допустимого диапазона
 

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

 sample_str = "Приветственное сообщение"
print (sample_str [1.25]) #index должен быть целым числом

# TypeError: строковые индексы должны быть целыми числами
 

Изменить / удалить строку в Python

Python Строки по своей конструкции неизменяемы. Это говорит о том, что

.

Строковые методы Python?

true
true строка начинается с указанного значения
Метод
Описание
Примеры
capitalize ()
Возвращает копию строки с заглавными буквами первого нижнего символа.
 >>> mystring = "hello python"
>>> печать (mystring.capitalize ())
Hello python 
Casefold ()
Возвращает свернутую копию строки.Строки с регистром могут использоваться для сопоставления без регистра.
 >>> mystring = "hello PYTHON"
>>> печать (mystring.casefold ())
hello python 
Центр (ширина, [fillchar])
Возвращает строку с центром в строке длиной шириной . Заполнение может быть выполнено с использованием указанного fillchar (заполнение по умолчанию использует пространство ASCII). Исходная строка возвращается, если ширина меньше или равна len (s)
 >>> mystring = "Hello"
>>> х = моя строка.центр (12,
"-")
>>> print (x)
--- Привет ---- 
Count (sub, [начало], [конец])
Возвращает количество неперекрывающихся вхождений подстроки ( sub ) в диапазоне [ начало , конец ]. Необязательные аргументы начало и конец интерпретируются как в нотации среза.
 >>> mystr = "Hello Python"
>>> print (mystr.count ("o"))
2
>>> print (mystr.count ("th"))
1
>>> print (mystr.count ("l"))
2
>>> print (mystr.count ("h"))
1
>>> print (mystr.count ("H"))
1
>>> print (mystr.count ("hH"))
0 
Encode (encoding = «utf-g», errors = «strict»)
Возвращает закодированную версию строки в виде байтового объекта. Кодировка по умолчанию — utf-8. могут быть заданы ошибки для установки другой схемы обработки ошибок. Возможные значения ошибок:

 >>> mystr = 'python!'
>>> print ('Строка:',
mystr)
Строка: python!
>>> print ('Закодированный
версия: ',
mystr.кодировать ("ascii",
"игнорировать"))
Закодированная версия:
b'python! '
>>> print ('Закодированный
версия (с заменой): ',
mystr.encode ("ascii",
"заменить"))
Закодированная версия (с
replace): b'python! ' 
заканчивается с (суффикс, [начало], [конец])
Возвращает True, если строка заканчивается указанным суффиксом, в противном случае возвращает False.
 >>> mystr = "Python"
>>>
печать (mystr.endswith ("y"))
Ложь
>>>
печать (mystr.заканчивается с ("хон"))
True 
Expandtabs (tabsize = 8)
Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции.
 >>> mystr = "1 \ t2 \ t3"
>>> печать (mystr)
1 2 3
>>>
печать (mystr.expandtabs ())
1 2 3
>>>
печать (mystr.expandtabs (tabsi
ze = 15))
1 2
3
>>>
печать (mystr.expandtabs (tabsi
ze = 2))
1 2 3 
Найти (sub, [начало], [конец])
Возвращает наименьший индекс в строке, где подстрока sub находится в пределах среза s [начало: конец].
 >>> mystring = "Python"
>>>
печать (mystring.find ("P"))
0
>>>
печать (mystring.find ("вкл"))
4 
Формат (* args, ** kwargs)
Выполняет операцию форматирования строки. Строка, для которой вызывается этот метод, может содержать буквальный текст или поля замены, разделенные фигурными скобками {}.
 >>> print ("{} и
{} ". format (" Apple ",
"Банан"))
Яблоко и банан
>>> print ("{1} и
{0} ".формат ("Яблоко",
"Банан"))
Банан и яблоко
>>> print ("{обед} и
{ужин} ". format (обед =" Горох
", обед =" Фасоль "))
Peas and Beans 
format_map (отображение)
Аналогично формату (** отображение), за исключением того, что отображение используется напрямую и не копируется в словарь.
 >>> обед = {"Еда":
«Пицца», «Напиток»: «Вино»}
>>> print ("Обед: {Еда},
{Напиток} ". Format_map (обед))
Обед: пицца, вино
>>> класс по умолчанию (dict):
def __missing __ (self,
ключ):
ключ возврата
>>> обед = {"Напиток":
"Вино"}
>>> print ("Обед: {Еда},
{Пить}".format_map (По умолчанию (
обед)))
Обед: еда, вино 
Индекс (sub, [начало], [конец])
Ищет в строке указанное значение и возвращает позицию, где оно было найдено
 >>> mystr = "HelloPython"
>>> print (mystr.index ("P"))
5
>>>
print (mystr.index ("hon"))
8
>>> print (mystr.index ("o"))
4 
isalnum
Возвращает True, если все символы в строке буквенно-цифровые
 >>> mystr = "HelloPython"
>>> print (mystr.isalnum ())
Правда
>>> a = "123"
>>> print (a.isalnum ())
Правда
>>> a = "$ *% !!!"
>>> print (a.isalnum ())
False 
Isalpha ()
Возвращает True, если все символы в строке находятся в алфавите
 >>> mystr = "HelloPython"
>>> печать (mystr.isalpha ())
Правда
>>> a = "123"
>>> print (a.isalpha ())
Ложь
>>> a = "$ *% !!!"
>>> print (a.isalpha ())
False 
Isdecimal ()
Возвращает True, если все символы в строке десятичные.
 >>> mystr = "HelloPython"
>>> print (mystr.isdecimal ())
Ложь
>>> a = "1,23"
>>> print (a.isdecimal ())
Ложь
>>> c = u "\ u00B2"
>>> печать (c.isdecimal ())
Ложь
>>> c = "133"
>>> печать (c.isdecimal ())
True 
Isdigit ()
Возвращает True, если все символы в строке являются цифрами
 >>> c = "133"
>>> печать (c.isdigit ())
Правда
>>> c = u "\ u00B2"
>>> печать (c.isdigit ())
Правда
>>> а = "1.23 "
>>> print (a.isdigit ())
False 
isidentifier ()
Возвращает True, если строка является идентификатором
 >>> c = "133"
>>> print (c.isidentifier ())
Ложь
>>> c = "_ user_123"
>>> print (c.isidentifier ())
Правда
>>> c = "Python"
>>> print (c.isidentifier ())
True 
Islower ()
Возвращает True, если все символы в строке строчные
 >>> c = "Python"
>>> print (c.islower ())
Ложь
>>> c = "_ user_123"
>>> печать (c.islower ())
Правда
>>> печать (c.islower ())
False 
Isnumeric ()
Возвращает True, если все символы в строке числовые
 >>> c = "133"
>>> print (c.isnumeric ())
Правда
>>> c = "_ user_123"
>>> print (c.isnumeric ())
Ложь
>>> c = "Python"
>>> print (c.isnumeric ())
False 
isprintable ()
Возвращает True, если все символы в строке можно распечатать
 >>> c = "133"
>>> print (c.isprintable ())
Правда
>>> c = "_ user_123"
>>> print (c.isprintable ())
Правда
>>> c = "\ t"
>>> print (c.isprintable ())
False 
isspace ()
Возвращает True, если все символы в строке являются пробелами
 >>> c = "133"
>>> печать (c.isspace ())
Ложь
>>> c = "Привет, Python"
>>> печать (c.isspace ())
Ложь
73
>>> c = "Привет"
>>> печать (c.isspace ())
Ложь
>>> c = "\ t"
>>> print (c.isspace ())
True 
istitle ()
Возвращает True, если строка соответствует правилам заголовка
 >>> c = "133"
>>> print (c.istitle ())
Ложь
>>> c = "Python"
>>> print (c.istitle ())
Правда
>>> c = "\ t"
>>> print (c.istitle ())
False 
isupper ()
Возвращает True, если все символы в строке являются прописными
 >>> c = "Python"
>>> print (c.isupper ())
Ложь
>>> c = "ПИХТОН"
>>> печать (c.isupper ())
Правда
>>> c = "\ t"
>>> печать (c.isupper ())
Ложь 
join (итерация)
Присоединяет элементы итерации к концу строки
 >>> a = "-"
>>> print (a.join ("123"))
1-2-3
>>> a = "Привет, Python"
>>> a = "**"
>>> print (a.join ("Привет
Python »))
Здравствуйте**
** P ** y ** t ** h ** o ** n 
ljust ( ширина [, fillchar ])
Возврат версия строки с выравниванием по левому краю
 >>> a = "Hello"
>>> б = а.ljust (12, "_")
>>> print (b)
Здравствуйте _______ 
lower ()
Преобразует строку в нижний регистр
 >>> a = "Python"
>>> print (a.lower ())
Python 
lstrip ([ символов ])
Возвращает левую обрезанную версию строки
 >>> a = "Hello"
>>> print (a.lstrip (), "!")
Здравствуйте, 
maketrans ( x [, y [, z ]])
Таблица переводов для переводов
 >>> frm = "SecretCode"
>>> to = "4203040540"
>>> trans_table =
ул.макетранс (фрм, к)
>>> sec_code = "Секрет
Код ".translate (trans_table)
>>> print (sec_code)
400304 0540 
раздел ( сен )
Возвращает кортеж, в котором строка разделена на три части
 >>> mystr = "Hello-Python"
>>> print (mystr.partition ("-
"))
('Привет', '-', 'Python')
74
>>>
print (mystr.partition ("."))
('Hello-Python', '', '') 
заменить ( старый , новый [, count ])
Возвращает строку, в которой указанное значение заменяется указанным значением.
 >>> mystr = "Hello Python.Привет, Java. Привет, C ++ ".
>>>
print (mystr.replace ("Привет",
"До свидания"))
Пока, Python. Пока, Java. до свидания
C ++.
>>>
print (mystr.replace ("Привет",
"Ад", 2))
Адский Python. Ад Ява.
Привет, C ++. 
rfind ( sub [, start [, end ]])
Ищет строку и возвращает указанное значение последняя позиция, на которой он был найден
 >>> mystr = "Hello-Python"
>>> print (mystr.rfind ("P"))
6
>>> print (mystr.rfind ("-"))
5
>>> print (mystr.rfind ("z"))
-1 
rindex ( sub [, start [, end ]])
Ищет строку и ищет строку возвращает последнюю позицию того места, где он был найден
 >>> mystr = "Hello-Python"
>>> print (mystr.rindex ("P"))
6
>>> print (mystr.rindex ("-"))
5
>>> print (mystr.rindex ("z"))
Traceback (последний вызов
последний):
Файл "", строка
1, в <модуль>
печать (mystr.rindex ("z"))
ValueError: подстрока не
найдено 
rjust ( width [, fillchar ])
Возвращает строку, выровненную по правому краю в строке длиной шириной .
 >>> mystr = "Hello Python"
>>> mystr1 = mystr.rjust (20,
"-")
>>> печать (mystr1)
-------- Hello Python 
rpartition ( sep )
Возвращает кортеж, в котором строка разделена на три части
 >>> mystr = "Привет, Python"
>>>
print (mystr.rpartition ("."))
('', '', 'Привет, Python')
>>> print (mystr.rpartition ("
"))
('Hello', '', 'Python') 
rsplit (sep = None, maxsplit = -1)
Разбивает строку по указанному разделителю и возвращает список
> >> mystr = "Привет, Python"
>>> print (mystr.rsplit ())
["Привет", "Python"]
>>> mystr = "Привет-Python-
Здравствуйте"
>>>
print (mystr.rsplit (sep = "-",
maxsplit = 1))
['Hello-Python', 'Hello'] 
rstrip ([ символов ])
Возвращает правую обрезанную версию строки
 >>> mystr = "Привет, Python"
>>> print (mystr.rstrip (),
"!")
Привет, Python!
>>> mystr = "------------
Привет, Python ----------- "
>>> print (mystr.rstrip (), "-
")
------------ Привет, Python ----
------- -
>>> print (mystr.rstrip (),
"_")
------------ Привет, Python ----
------- _ 
split (sep = None, maxsplit = -1)
Разбивает строку по указанному разделителю и возвращает список
 >>> mystr = "Привет, Python"
>>> печать (mystr.split ())
["Привет", "Python"]
>>> mystr1 = "Привет ,, Python"
>>> print (mystr1.split (","))
['Hello', '', 'Python'] 
splitlines ([keepends])
Разбивает строку по разрывам строки и возвращает список
 >>> mystr = "Hello: \ п \ п
Python \ r \ nJava \ nC ++ \ n "
>>>
печать (mystr.splitlines ())
['Привет:', '', 'Python',
"Java", "C ++"]
>>>
печать (mystr.splitlines (keepe
nds = True))
['Привет: \ n', '\ n', '
Python \ r \ n ',' Java \ n ',
'C ++ \ n'] 
начинается с ( префикс [, начало [, конец ]])
 >>> mystr = "Hello Python"
>>>
печать (mystr.начинается с ("P"))
Ложь
>>>
печать (mystr.startswith ("H"))
Правда
>>>
print (mystr.startswith ("Ад
"))
True 
strip ([ chars ])
Возвращает обрезанную версию строки
 >>> mystr = "
Привет, Python
"
>>> print (mystr.strip (),
"!")
Привет, Python!
>>> print (mystr.strip (), "
")
Hello Python 
swapcase ()
Меняет местами регистр, нижний регистр становится верхним и наоборот
 >>> mystr = "Hello PYthon"
>>> print (mystr.swapcase ())
hELLO python 
title ()
Преобразует первый символ каждого слова в верхний регистр
 >>> mystr = "Hello PYthon"
>>> print (mystr.title ())
Привет, Python
>>> mystr = "ПРИВЕТ, ЯВА"
>>> print (mystr.title ())
Hello Java 
translate ( table )
Возвращает переведенную строку
 >>> frm = "helloPython"
>>> to = "40250666333"
>>> trans_table =
ул.макетранс (фрм, к)
>>> secret_code = "Секрет
Код ".translate (trans_table)
>>> print (secret_code)
S0cr06 C3d0 
upper ()
Преобразует строку в верхний регистр
 >>> mystr = "hello Python"
>>> печать (mystr.upper ())
HELLO PYTHON 
zfill ( width )
Заполняет строку указанным числом 0 значений в начале
 >>> mystr = "999"
>>> print (mystr.zfill (9))
000000999
>>> mystr = "-40"
>>> печать (mystr.zfill (5))
-0040 
.

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

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

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa