Строка питон: Методы строк | Python

Содержание

Строки. Урок 21 курса «Python. Введение в программирование»

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

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

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

>>> s = "Hello, World!"
>>> s[0]
'H'
>>> s[7:]
'World!'
>>> s[::2]
'Hlo ol!'

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

Важным отличием от списков является неизменяемость строк в Python. Нельзя перезаписать какой-то отдельный символ или срез в строке:

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

Интерпретатор сообщает, что объект типа str не поддерживает присвоение элементам.

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

>>> s = s[0:-1] + '.'
>>> s
'Hello, World.'

В примере берется срез из исходной строки, соединяется с другой строкой. Получается новая строка, которая присваивается переменной s. Ее старое значение при этом теряется.

Методы строк

В Python для строк есть множество методов. Посмотреть их можно по команде

dir(str), получить информацию по каждому – help(str.имя_метода). Рассмотрим наиболее интересные из них.

Методы split() и join()

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

>>> s = input()
red blue orange white
>>> s
'red blue orange white'
>>> sl = s.split()
>>> sl
['red', 'blue', 'orange', 'white']
>>> s
'red blue orange white'

Список, возвращенный методом split(), мы могли бы присвоить той же переменной s, то есть s = s.split(). Тогда исходная строка была бы потеряна. Если она не нужна, то лучше не вводить дополнительную переменную.

Метод split() может принимать необязательный аргумент-строку, указывающей по какому символу или подстроке следует выполнить разделение:

>>> s.split('e')
['r', 'd blu', ' orang', ' whit', '']
>>> '40030023'.split('00')
['4', '3', '23']

Метод строк join() выполняет обратное действие. Он формирует из списка строку. Поскольку это метод строки, то впереди ставится строка-разделитель, а в скобках — передается список:

>>> '-'.join(sl)
'red-blue-orange-white'

Если разделитель не нужен, то метод применяется к пустой строке:

>>> ''.join(sl)
'redblueorangewhite'

Методы find() и replace()

Данные методы строк работают с подстроками. Методы find() ищет подстроку в строке и возвращает индекс первого элемента найденной подстроки. Если подстрока не найдена, то возвращает -1.

>>> s
'red blue orange white'
>>> s.find('blue')
4
>>> s.find('green')
-1

Поиск может производиться не во всей строке, а лишь на каком-то ее отрезке. В этом случае указывается первый и последний индексы отрезка. Если последний не указан, то ищется до конца строки:

>>> letters = 'ABCDACFDA'
>>> letters.find('A', 3)
4
>>> letters.find('DA', 0, 6)
3

Здесь мы ищем с третьего индекса и до конца, а также с первого и до шестого. Обратите внимания, что метод find() возвращает только первое вхождение. Так выражение letters.find('A', 3) последнюю букву ‘A’ не находит, так как ‘A’ ему уже встретилась под индексом 4.

Метод replace() заменяет одну подстроку на другую:

>>> letters.replace('DA', 'NET')
'ABCNETCFNET'

Исходная строка, конечно, не меняется:

Так что если результат надо сохранить, то его надо присвоить переменной:

>>> new_letters = letters.replace('DA', 'NET')
>>> new_letters
'ABCNETCFNET'

Метод format()

Строковый метод format() уже упоминался при рассмотрении вывода на экран с помощью функции print():

>>> print("This is a {0}. It's {1}."
... .format("ball", "red"))
This is a ball. It's red.

Однако к print() он никакого отношения не имеет, а применяется к строкам. Лишь потом заново сформированная строка передается в функцию вывода.

Возможности format() широкие, рассмотрим основные.

>>> s1 = "length - {}, width - {}, height - {}"
>>> s1.format(3, 6, 2.3)
'length - 3, width - 6, height — 2.3'

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

>>> s2 = "height - {1}, length - {0}"
>>> s2.format(3, 6)
'height - 6, length - 3'

Кроме того, аргументы могут передаваться по слову-ключу:

>>> info = "This is a {subj}. It's {prop}."
>>> info.format(subj="table", prop="small")
"This is a table. It's small."

Пример форматирования вещественных чисел:

>>> "{1:.2f} {0:.3f}".format(3.33333, 10/6)
'1.67 3.333'

Практическая работа

  1. Вводится строка, включающая строчные и прописные буквы. Требуется вывести ту же строку в одном регистре, который зависит от того, каких букв больше. При равном количестве преобразовать в нижний регистр. Например, вводится строка «HeLLo World», она должна быть преобразована в «hello world», потому что в исходной строке малых букв больше. В коде используйте цикл for, строковые методы upper() (преобразование к верхнему регистру) и lower() (преобразование к нижнему регистру), а также методы isupper()

    и islower(), проверяющие регистр строки или символа.

  2. Строковый метод isdigit() проверяет, состоит ли строка только из цифр. Напишите программу, которая запрашивает с ввода два целых числа и выводит их сумму. В случае некорректного ввода программа не должна завершаться с ошибкой, а должна продолжать запрашивать числа. Обработчик исключений try-except использовать нельзя.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Руководство Python String

Строка (string) является одним из самых распространённых видов (type) в Python, и вам часто приходится работать с ними. На заметку, в Python не существует вида символа (character), символ просто считается одной строкой (string) имеющая длину 1.

Есть 2 способа объявлять одну строку (string) написанную на одной линии (line), это использование апострофа или ковычек.

str1 = "Hello Python" str2 = 'Hello Python' str3 = "I'm from Vietnam" str4 = 'This is a "Cat"! '

Если вы хотите написать строку (string) на нескольких линиях, используйте тройной апостроф.


str = """Hello World
     Hello Python"""

2- Доступ значений в string

Python не поддерживает вид символа (Character type), символ рассматривается как строка с длиной 1. Все символы в строке индексированы с 0. Вы можете получить доступ к подстрокам (substring) с помощью индексов.

stringExample.py


mystr = "This is text"

# --> h
print ("mystr[1] = ", mystr[1])

# --> is is t
print ("mystr[2,9] = ", mystr[2:9])

# --> s is text
print ("mystr[3:] = ", mystr[3:])

3- String является неизменным (immuable)

Строка (string) является особенным видом данных в Python, и она неизменна (immuable). Каждая строка имеет адресс хранения в памяти (memory). Все действия со строками (string) создают другой объект. Например, если вы хотите связать (concatenate) одну строку с другой, эта действие создает другую строку в памяти.

Оператор == и is 

Python использует == оператор, чтобы сравнить значения двух объектов. И использует «is» оператор, чтобы сравнить местоположения в памяти (Memory).

compareObject.py


class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Override __eq__ method
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age 

jack1 = Person('Jack', 23)
jack2 = Person('Jack', 23)

# Call to __eq__ method
print ("jack1 == jack2 ?", jack1 == jack2) # True 
print ("jack1 is jack2 ?", jack1 is jack2) # False

Смотрите так же:

Строка (string) является особенным видом данных и часто используется в приложении 

Python. И поэтому имеет некоторые особенности:

• Если вы объявляете две переменные вида string со следующим значением, они все укажут на одну реальную строку в памяти (memory).

Операторы со строками создадут новую строку в памяти (memory).

compareString.py


str1 = "Hello Python" 
str2 = "Hello Python" 
str3 = "Hello " + "Python"

# --> True
print ("str1 == str2? ", str1 == str2)

# --> True
print ("str1 is str2? ", str1 is str2)

# --> True
print ("str1 == str3? ", str1  == str3)

# --> False
print ("str1 is str3? ", str1 is str3)

4- Символы выхода (Escape Characters)

Escape символы (Escape characters) являются особенными символами в Python. Эти символы непечатные (non-printable). Все же, если вы хотите, чтобы они были в вашей строке, вам нужно обозначение, чтобы оповестить Python. Например, «\n» это символ новой строки (newline).

escapeCharacterExample.py


# Two "tab" characters between "Hello World" and "Hello Python".
mystr = "Hello World\t\tHello Python" 
print (mystr)

# Two "newline" characters between "Hello World" and "Hello Python".
mystr = "Hello World\n\nHello Python" 
print (mystr)

Output:


Hello World       Hello Python
Hello World

Hello Python
Backslash
notation
Hexadecimal
character
Description
\a 0x07 Bell or alert
\b 0x08 Backspace
\cx   Control-x
\C-x   Control-x
\e 0x1b Escape
\f 0x0c Formfeed
\M-\C-x   Meta-Control-x
\n 0x0a Newline
\nnn   Octal notation, where n is in the range 0.7
\r 0x0d Carriage return
\s 0x20 Space
\t 0x09 Tab
\v 0x0b Vertical tab
\x   Character x
\xnn   Hexadecimal notation, where n is in the range 0.9, a.f, or A.F

5- Операторы для string

В Python есть несколько особенных операторов ниже:

ОператорОписаниеПример
+Связать (concatenate) 2 string, создать новый string.«Hello» +»Python» ==> «Hello Python»
*Создать новый string связав (concatenate) много раз копию одной string.«Hello»*2 ==> «HelloHello»
[]Возвращает символ на место данное индексом.a = «Hello»
a[1] ==> «e»
[ : ]Возвращает подстроку содержащую символы данные диапазоном (range)a = «Hello»
a[1:4] ==> «ell»
a[1: ] ==> «ello»
inВозвращает True если символ существует в данной string.a = «Hello»
‘H’ in a ==> True
not inВозвращает True если символ не существует в данной string.a = «Hello»
‘M’ not in a ==> True
r/RНеобработанная строка (Raw String) — Предотвращает реальное значение символов выхода (Escape character). Синтаксис для необработанной строки и для обычной строки одинаковые, за исключением «оператор необработанной строки», буква «r» стоит перед ковычками. «R» может быть строчной буквой (r) или прописной (R) и должна быть расположена пере первой ковычкой.print (r’\n\t’) ==> \n\t
print (R’\n\t’) ==> \n\t
%Формат stringСмотрите ниже.

str (строка) в Python

Строка — базовый тип представляющий из себя неизменяемую последовательность символов; str от «string» — «строка».

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

Начиная с +py3.0 имеется в виду последовательность кодовых точек Unicode (соответствует типу unicode в предыдущих версиях Python).

До -py3.0 последовательность представляла из себя строку байт (поддерживает ASCII).

Поскольку в языке нет типа для одиночного символа (character, char), то обращение к строке при помощи индекса: my_str[1] — возвращает новую строку с символом по этому индексу.


Строковые литералы могут быть записаны разными способами:
    # Одиночные кавычки. Часто встречаемый вариант записи.
my_str = 'а внутри "можно" поместить обычные'

# Кавычки.
my_str = "а внутри 'можно' поместить одиночные"

# Три одиночных кавычки. Удобно для записей в несколько строк
my_str = '''В трёх одиночных
кавычках'''

# Тройные кавычки. Общепринятый способ для строк документации.
my_str = """Three double quotes"""


Строковые литералы, содержащие промеж себя только пробел объединяются в единую строку:
    ('Кот' 'обус') == 'Котобус'

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

Другие типы могут быть приведены к строке при помощи конструктора str(): str(obj).
    str(10)  # '10'
str(len) # '<built-in function len>'

Таким образом можно получить «неформальное» строковое представление объектов. Для пользовательских типов такое представление может быть определено в специализированном методе __str__.

В случае, если получить строковое представление не удалось, производится попытка получить «формальное» представление (см. repr).

Синонимы поиска: str (строка), строки, строковые методы, функции для строк, преобразование в строку, методы строк, char

41 вопрос о работе со строками в Python / Хабр

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

Быть хорошим программистом — это не значит помнить все встроенные функции некоего языка. Но это не означает и того, что их запоминание — бесполезное дело. Особенно — если речь идёт о подготовке к собеседованию.

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



1. Как проверить два объекта на идентичность?

Оператор

is

возвращает

True

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

Не стоит путать is и ==. Оператор == проверяет лишь равенство объектов.

animals           = ['python','gopher']
more_animals      = animals
print(animals == more_animals) #=> True
print(animals is more_animals) #=> True
even_more_animals = ['python','gopher']
print(animals == even_more_animals) #=> True
print(animals is even_more_animals) #=> False

Обратите внимание на то, что

animals

и

even_more_animals

не идентичны, хотя и равны друг другу.

Кроме того, существует функция id(), которая возвращает идентификатор адреса памяти, связанного с именем переменной. При вызове этой функции для двух идентичных объектов будет выдан один и тот же идентификатор.

name = 'object'
id(name)
#=> 4408718312

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

Существует строковый метод

istitle()

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

print( 'The Hilton'.istitle() ) #=> True
print( 'The dog'.istitle() ) #=> False
print( 'sticky rice'.istitle() ) #=> False

3. Как проверить строку на вхождение в неё другой строки?

Существует оператор

in

, который вернёт

True

в том случае, если строка содержит искомую подстроку.

print( 'plane' in 'The worlds fastest plane' ) #=> True
print( 'car' in 'The worlds fastest plane' ) #=> False

4. Как найти индекс первого вхождения подстроки в строку?

Есть два метода, возвращающих индекс первого вхождения подстроки в строку. Это —

find()

и

index()

. У каждого из них есть определённые особенности.

Метод find() возвращает -1 в том случае, если искомая подстрока в строке не найдена.

'The worlds fastest plane'.find('plane') #=> 19
'The worlds fastest plane'.find('car') #=> -1

Метод

index()

в подобной ситуации выбрасывает ошибку

ValueError

.

'The worlds fastest plane'.index('plane') #=> 19
'The worlds fastest plane'.index('car') #=> ValueError: substring not found

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

Функция

len()

возвращает длину строки.

len('The first president of the organization..') #=> 41

6. Как подсчитать то, сколько раз определённый символ встречается в строке?

Ответить на этот вопрос нам поможет метод

count()

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

'The first president of the organization..'.count('o') #=> 3

7. Как сделать первый символ строки заглавной буквой?

Для того чтобы это сделать, можно воспользоваться методом

capitalize()

.

'florida dolphins'.capitalize() #=> 'Florida dolphins'

8. Что такое f-строки и как ими пользоваться?

В Python 3.6 появилась новая возможность — так называемые «f-строки». Их применение чрезвычайно упрощает интерполяцию строк. Использование f-строк напоминает применение метода

format()

.

При объявлении f-строк перед открывающей кавычкой пишется буква f.

name = 'Chris'
food = 'creme brulee'
f'Hello. My name is {name} and I like {food}.'
#=> 'Hello. My name is Chris and I like creme brulee'

9. Как найти подстроку в заданной части строки?

Метод

index()

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

'the happiest person in the whole wide world.'.index('the',10,44)
#=> 23

Обратите внимание на то, что вышеприведённая конструкция возвращает

23

, а не

0

, как было бы, не ограничь мы поиск.

'the happiest person in the whole wide world.'.index('the')
#=> 0

10. Как вставить содержимое переменной в строку, воспользовавшись методом format()?

Метод

format()

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

format()

не так удобно, так как все переменные приходится указывать в качестве аргументов

format()

.

difficulty = 'easy'
thing = 'exam'
'That {} was {}!'.format(thing, difficulty)
#=> 'That exam was easy!'

11. Как узнать о том, что в строке содержатся только цифры?

Существует метод

isnumeric()

, который возвращает

True

в том случае, если все символы, входящие в строку, являются цифрами.

'80000'.isnumeric() #=> True

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

'1.0'.isnumeric() #=> False

12. Как разделить строку по заданному символу?

Здесь нам поможет метод

split()

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

'This is great'.split(' ')
#=> ['This', 'is', 'great']
'not--so--great'.split('--')
#=> ['not', 'so', 'great']

13. Как проверить строку на то, что она составлена только из строчных букв?

Метод

islower()

возвращает

True

только в том случае, если строка составлена исключительно из строчных букв.

'all lower case'.islower() #=> True
'not aLL lowercase'.islower() # False

14. Как проверить то, что строка начинается со строчной буквы?

Сделать это можно, вызвав вышеописанный метод

islower()

для первого символа строки.

'aPPLE'[0].islower() #=> True

15. Можно ли в Python прибавить целое число к строке?

В некоторых языках это возможно, но Python при попытке выполнения подобной операции будет выдана ошибка

TypeError

.

'Ten' + 10 #=> TypeError

16. Как «перевернуть» строку?

Для того чтобы «перевернуть» строку, её можно разбить, представив в виде списка символов, «перевернуть» список, и, объединив его элементы, сформировать новую строку.

''.join(reversed("hello world"))
#=> 'dlrow olleh'

17. Как объединить список строк в одну строку, элементы которой разделены дефисами?

Метод

join()

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

'-'.join(['a','b','c'])
#=> 'a-b-c'

18. Как узнать о том, что все символы строки входят в ASCII?

Метод

isascii()

возвращает

True

в том случае, если все символы, имеющиеся в строке, входят в ASCII.

print( 'Â'.isascii() ) #=> False
print( 'A'.isascii() ) #=> True

19. Как привести всю строку к верхнему или нижнему регистру?

Для решения этих задач можно воспользоваться методами

upper()

и

lower()

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

sentence = 'The Cat in the Hat'
sentence.upper() #=> 'THE CAT IN THE HAT'
sentence.lower() #=> 'the cat in the hat'

20. Как преобразовать первый и последний символы строки к верхнему регистру?

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

animal = 'fish'
animal[0].upper() + animal[1:-1] + animal[-1].upper()
#=> 'FisH'

21. Как проверить строку на то, что она составлена только из прописных букв?

Имеется метод

isupper()

, который похож на уже рассмотренный

islower()

. Но

isupper()

возвращает

True

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

'Toronto'.isupper() #=> False
'TORONTO'.isupper() #= True

22. В какой ситуации вы воспользовались бы методом splitlines()?

Метод

splitlines()

разделяет строки по символам разрыва строки.

sentence = "It was a stormy night\nThe house creeked\nThe wind blew."
sentence.splitlines()
#=> ['It was a stormy night', 'The house creeked', 'The wind blew.']

23. Как получить срез строки?

Для получения среза строки используется синтаксическая конструкция следующего вида:

string[start_index:end_index:step]

Здесь

step

— это шаг, с которым будут возвращаться символы строки из диапазона

start_index:end_index

. Значение

step

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

string = 'I like to eat apples'
string[:6] #=> 'I like'
string[7:13] #=> 'to eat'
string[0:-1:2] #=> 'Ilk oetape' (каждый 2-й символ)

24. Как преобразовать целое число в строку?

Для преобразования числа в строку можно воспользоваться конструктором

str()

.

str(5) #=> '5'

25. Как узнать о том, что строка содержит только алфавитные символы?

Метод

isalpha()

возвращает

True

в том случае, если все символы в строке являются буквами.

'One1'.isalpha() #=> False
'One'.isalpha() #=> True

26. Как в заданной строке заменить на что-либо все вхождения некоей подстроки?

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

replace()

.

sentence = 'Sally sells sea shells by the sea shore'
sentence.replace('sea', 'mountain')
#=> 'Sally sells mountain shells by the mountain shore'

27. Как вернуть символ строки с минимальным ASCII-кодом?

Если взглянуть на ASCII-коды элементов, то окажется, например, что прописные буквы имеют меньшие коды, чем строчные. Функция

min()

возвращает символ строки, имеющий наименьший код.

min('strings') #=> 'g'

28. Как проверить строку на то, что в ней содержатся только алфавитно-цифровые символы?

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

isalnum()

.

'Ten10'.isalnum() #=> True
'Ten10.'.isalnum() #=> False

29. Как удалить пробелы из начала строки (из её левой части), из её конца (из правой части), или с обеих сторон строки?

Здесь нам пригодятся, соответственно, методы

lstrip()

,

rstrip()

и

strip()

.

string = '  string of whitespace    '
string.lstrip() #=> 'string of whitespace    '
string.rstrip() #=> '  string of whitespace'
string.strip() #=> 'string of whitespace'

30. Как проверить то, что строка начинается с заданной последовательности символов, или заканчивается заданной последовательностью символов?

Для ответа на этот вопрос можно прибегнуть, соответственно, к методам

startswith()

и

endswith()

.

city = 'New York'
city.startswith('New') #=> True
city.endswith('N') #=> False

31. Как закодировать строку в ASCII?

Метод

encode()

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

utf-8

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

UnicodeEncodeError

.

'Fresh Tuna'.encode('ascii')
#=> b'Fresh Tuna'
'Fresh Tuna Â'.encode('ascii')
#=> UnicodeEncodeError: 'ascii' codec can't encode character '\xc2' in position 11: ordinal not in range(128)

32. Как узнать о том, что строка включает в себя только пробелы?

Есть метод

isspace()

, который возвращает

True

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

''.isspace() #=> False
' '.isspace() #=> True
'   '.isspace() #=> True
' the '.isspace() #=> False

33. Что случится, если умножить некую строку на 3?

Будет создана новая строка, представляющая собой исходную строку, повторённую три раза.

'dog' * 3
# 'dogdogdog'

34. Как привести к верхнему регистру первый символ каждого слова в строке?

Существует метод

title()

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

'once upon a time'.title() #=> 'Once Upon A Time'

35. Как объединить две строки?

Для объединения строк можно воспользоваться оператором

+

.

'string one' + ' ' + 'string two' 
#=> 'string one string two'

36. Как пользоваться методом partition()?

Метод

partition()

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

sentence = "If you want to be a ninja"
print(sentence.partition(' want '))
#=> ('If you', ' want ', 'to be a ninja')

37. Строки в Python иммутабельны. Что это значит?

То, что строки иммутабельны, говорит о том, что после того, как создан объект строки, он не может быть изменён. При «модификации» строк исходные строки не меняются. Вместо этого в памяти создаются совершенно новые объекты. Доказать это можно, воспользовавшись функцией

id()

.

proverb = 'Rise each day before the sun'
print( id(proverb) )
#=> 4441962336
proverb_two = 'Rise each day before the sun' + ' if its a weekday'
print( id(proverb_two) )
#=> 4442287440

При конкатенации

'Rise each day before the sun'

и

' if its a weekday'

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

38. Если объявить одну и ту же строку дважды (записав её в 2 разные переменные) — сколько объектов будет создано в памяти? 1 или 2?

В качестве примера подобной работы со строками можно привести такой фрагмент кода:

animal = 'dog'
pet = 'dog'

При таком подходе в памяти создаётся лишь один объект. Когда я столкнулся с этим в первый раз, мне это не показалось интуитивно понятным. Но этот механизм помогает Python экономить память при работе с длинными строками.

Доказать это можно, прибегнув к функции id().

animal = 'dog'
print( id(animal) )
#=> 4441985688
pet = 'dog'
print( id(pet) )
#=> 4441985688

39. Как пользоваться методами maketrans() и translate()?

Метод

maketrans()

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

Метод translate() позволяет применить заданную таблицу для преобразования строки.

# создаём отображение
mapping = str.maketrans("abcs", "123S")
# преобразуем строку
"abc are the first three letters".translate(mapping)
#=> '123 1re the firSt three letterS'

Обратите внимание на то, что в строке произведена замена символов

a

,

b

,

c

и

s

, соответственно, на символы

1

,

2

,

3

и

S

.

40. Как убрать из строки гласные буквы?

Один из ответов на этот вопрос заключается в том, что символы строки перебирают, пользуясь механизмом List Comprehension. Символы проверяют, сравнивая с кортежем, содержащим гласные буквы. Если символ не входит в кортеж — он присоединяется к новой строке.

string = 'Hello 1 World 2'
vowels = ('a','e','i','o','u')
''.join([c for c in string if c not in vowels])
#=> 'Hll 1 Wrld 2'

41. В каких ситуациях пользуются методом rfind()?

Метод

rfind()

похож на метод

find()

, но он, в отличие от

find()

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

story = 'The price is right said Bob. The price is right.'
story.rfind('is')
#=> 39

Итоги

Я часто объясняю одному продакт-менеджеру, человеку в возрасте, что разработчики — это не словари, хранящие описания методов объектов. Но чем больше методов помнит разработчик — тем меньше ему придётся гуглить, и тем быстрее и приятнее ему будет работаться. Надеюсь, теперь вы без труда ответите на рассмотренные здесь вопросы.

Уважаемые читатели! Что, касающееся обработки строк в Python, вы посоветовали бы изучить тем, кто готовится к собеседованию?

Python | Основные методы строк

Основные методы строк

Последнее обновление: 02.05.2017

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

  • isalpha(): возвращает True, если строка состоит только из алфавитных символов

  • islower(): возвращает True, если строка состоит только из символов в нижнем регистре

  • isupper(): возвращает True, если все символы строки в верхнем регистре

  • isdigit(): возвращает True, если все символы строки — цифры

  • isnumeric(): возвращает True, если строка представляет собой число

  • startswith(str): возвращает True, если строка начинается с подстроки str

  • endswith(str): возвращает True, если строка заканчивается на подстроку str

  • lower(): переводит строку в нижний регистр

  • upper(): переводит строку в вехний регистр

  • title(): начальные символы всех слов в строке переводятся в верхний регистр

  • capitalize(): переводит в верхний регистр первую букву только самого первого слова строки

  • lstrip(): удаляет начальные пробелы из строки

  • rstrip(): удаляет конечные пробелы из строки

  • strip(): удаляет начальные и конечные пробелы из строки

  • ljust(width): если длина строки меньше параметра width, то справа от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по левому краю

  • rjust(width): если длина строки меньше параметра width, то слева от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по правому краю

  • center(width): если длина строки меньше параметра width, то слева и справа от строки равномерно добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по центру

  • find(str[, start [, end]): возвращает индекс подстроки в строке. Если подстрока не найдена, возвращается число -1

  • replace(old, new[, num]): заменяет в строке одну подстроку на другую

  • split([delimeter[, num]]): разбивает строку на подстроки в зависимости от разделителя

  • join(strs): объединяет строки в одну строку, вставляя между ними определенный разделитель

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


string = input("Введите число: ")
if string.isnumeric():
    number = int(string)
    print(number)

Проверка, начинается или оканчивается строка на определенную подстроку:


file_name = "hello.py"

starts_with_hello = file_name.startswith("hello")   # True
ends_with_exe = file_name.endswith("exe")           # False

Удаление пробелов в начале и в конце строки:


string = "   hello  world!  "
string = string.strip()
print(string)           # hello  world!

Дополнение строки пробелами и выравнивание:


print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

Консольный вывод:


iPhone 7:      52000
Huawei P10:      36000

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

Для поиска подстроки в строке в Python применяется метод find(), который возвращает индекс первого вхождения подстроки в строку и имеет три формы:

  • find(str): поиск подстроки str ведется с начала строки до ее конца

  • find(str, start): параметр start задает начальный индекс, с которого будет производиться поиск

  • find(str, start, end): параметр end задает конечный индекс, до которого будет идти поиск

Если подстрока не найдена, метод возвращает -1:


welcome = "Hello world! Goodbye world!"
index = welcome.find("wor")
print(index)       # 6

# поиск с 10-го индекса
index = welcome.find("wor",10)
print(index)       # 21

# поиск с 10 по 15 индекс
index = welcome.find("wor",10,15)
print(index)       # -1

Замена в строке

Для замены в строке одной подстроки на другую применяется метод replace():

  • replace(old, new): заменяет подстроку old на new

  • replace(old, new, num): параметр num указывает, сколько вхождений подстроки old надо заменить на new


phone = "+1-234-567-89-10"

# замена дефисов на пробел
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# удаление дефисов
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# замена только первого дефиса
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

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

Метод split() разбивает строку на список подстрок в зависимости от разделителя. В качестве разделителя может выступать любой символ или последовательность символов. Данный метод имеет следующие формы:

  • split(): в качестве разделителя используется пробел

  • split(delimeter): в качестве разделителя используется delimeter

  • split(delimeter, num): параметр num указывает, сколько вхождений delimeter используется для разделения. Оставшаяся часть строки добавляется в список без разделения на подстроки


text = "Это был огромный, в два обхвата дуб, с обломанными ветвями и с обломанной корой"
# разделение по пробелам
splitted_text = text.split()
print(splitted_text)
print(splitted_text[6])     # дуб,

# разбиение по запятым
splitted_text = text.split(",")
print(splitted_text)
print(splitted_text[1])     # в два обхвата дуб

# разбиение по первым пяти пробелам
splitted_text = text.split(" ", 5)
print(splitted_text)        
print(splitted_text[5])     # обхвата дуб, с обломанными ветвями и с обломанной корой

Соединение строк

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


words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"]

# разделитель - пробел
sentence = " ".join(words)
print(sentence)  # Let me speak from my heart in English

# разделитель - вертикальная черта
sentence = " | ".join(words)
print(sentence)  # Let | me | speak | from | my | heart | in | English

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


word = "hello"
joined_word = "|".join(word)
print(joined_word)      # h|e|l|l|o

Python: String (Строки)

Статья проплачена кошками — всемирно известными производителями котят.

Если статья вам понравилась, то можете поддержать проект.

format
F-strings: новый способ форматирования
Байтовые строки

В Python строки относятся к классу str вместо привычных String в других языках. Полный список методов класса можно узнать через команду:


print(str)

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


print("Мурзик")
print('Барсик')
print('Рыжик любил полежать на крыше автомобиля "Жигули"')

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


print("Мурзик\t5 лет") # табуляция
print('Рыжик любил полежать \nна крыше автомобиля "Жигули"') # перевод строки
print(r'D:\cats.txt') # отключение экранирования

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


pushkin = """У лукоморья дуб зелёный;
Златая цепь на дубе том:
И днём и ночью кот учёный
Всё ходит по цепи кругом;
Идёт направо - песнь заводит,
Налево - сказку говорит."""
print(pushkin)

Длину строки можно узнать через метод len().


str = "cat"
print(len(str)) # 3

Склеиваем две строки

Склейка двух строк (concatinate) происходит очень просто через сложение.


str1 = "Hello"
str2 = "Kitty"
concat = str1 + " " + str2
print(concat)

Метод split(): разбить строку

Разбить строку по указанному разделителю можно через функцию split(). По умолчанию в качестве разделителя используется пробел.


terminator = "I\'ll be back."
list = terminator.split()
print(list[0]) # I'll

Укажем разделитель явно.


myString = "one|two|three"
list = myString.split("|")
print(list[1])

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


myString = "one|two|three"
list = myString.split("|", 1)
print(list[1]) # two|three

«Умножаем» строку (повтор)

Довольно неожиданный оператор, который не встречал в других языках. Оказывается, строку можно «умножить». На самом деле, оператор позволяет повторить строку указанное число раз.


str = "cat"
repeatedStr = str * 3
print(repeatedStr)

Доступ к отдельному символу можно получить по индексу.


cat = "кот"
print(cat[0])
print(cat[1])
print(cat[2])

Можно указывать отрицательные значения, тогда отсчёт пойдёт с конца строки, начиная с -1.


cat = "кот"
print(cat[-1]) # т
print(cat[-2]) # о
print(cat[-3]) # к

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


cat = "скотина"
print(cat[1:4]) # кот

Возможные другие варианты среза. Смотрите примеры.


cat = "скотина"
print(cat[1:-3]) # кот
print(cat[:4])   # скот
print(cat[3:])   # тина
print(cat[:])    # скотина

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


cat = "скотина"
print(cat[::-1])  # анитокс
print(cat[1:6:2]) # ктн
print(cat[2::2])  # оиа

Для удаления символов новой строки в конце строки можно использовать метод rstrip(«\r\n») без удаления конечных пробелов:


>>> lines = ("line 1 \r\n"
... "\r\n"
... "\r\n")
>>> lines.rstrip("\r\n")
'line 1 '

Также есть всевозможные функции перевода в верхний/нижний регистр, проверок на наличие цифр и т.п.

format

Мощная функция с большими возможностями для форматирования строк.

Если для подстановки требуется только один аргумент, то значение — сам аргумент:


print('Hello, {} !'.format('Kitty'))

Другие варианты.


print('{1}, {0}, {2}'.format('Кошка', 'Кот', 'Котёнок')) # Кот, Кошка, Котёнок
print('{}, {}, {}'.format('Кошка', 'Кот', 'Котёнок')) # Кошка, Кот, Котёнок

На самом деле функцию следует изучить по документации, слишком много вариантов.

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


print('Барсик')
print('Мурзик', end='')
print('Васька')

# Результат Барсик МурзикВаська

F-strings: новый способ форматирования

Всё же format() не слишком читабелен и удобен при большом количестве параметров. Гораздо приятнее использовать новый способ. Нужно всего лишь подставить символ f перед кавычками и затем просто подставлять имена переменных в фигурных скобках.


catName = 'Рыжик'
age = 7
print(f"Моего кота зовут {catName}, ему {age} лет")

Байтовые строки

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

Создадим байтовую строку.


b'bytes'
# b'bytes'

'Байты'.encode('utf-8')
# b'\xd0\x91\xd0\xb0\xd0\xb9\xd1\x82\xd1\x8b'

bytes('bytes', encoding = 'utf-8')
# b'bytes'

bytes([50, 100, 76, 72, 41]) # числам от 0 до 255 соответствуют символы как у chr()
# b'2dLH)'

Байтовые строки используют для записи в файл или чтения из него.

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


b'\xd0\x91\xd0\xb0\xd0\xb9\xd1\x82\xd1\x8b'.decode('utf-8')
# 'Байты'
Реклама

Правила форматирования строк в Python с примерами использования / Skillbox Media

Форматирование и вывод строк — одна из наиболее типичных задач в любом языке программирования. Однако в Python до версии 3.6 у нас было, по большому счёту, всего два способа:

  • оператор %;
  • функция format().

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

str_1 = "Name: %s, email: %s, phone: %s" % (name, email, phone)
str_2 = "Name: {}, email: {}, phone: {}".format(name, email, phone)

Что там говорят на вводных уроках про читаемость кода в Python?

Первый вариант никуда не годен: мало того что надо бегать глазами туда-сюда по строке, — надо ещё помнить о ключах после символа % (для разных типов они разные, s — для строк) и не забыть поставить ещё один % между строкой и кортежем с переменными.

Второй вариант, то есть функция .format(), чуть получше, так как параметры-заменители в фигурных скобках облегчают читаемость, но всё равно не вполне подходит для строк с большим количеством переменных.

Так жить нельзя, решил однажды Гвидо ван Россум, и в версии 3.6 появились
f-strings, они же formatted string literals, — литералы форматированных строк. Или просто форматированные строки, эф-строки, или даже, не побоимся этого слова, эф-стринги. Строки в Python’е стали «питоничнее» — компактнее, удобнее, читаемее.

Цокто Жигмытов

С некоторых пор утверждает, что он data scientist. В предыдущих сезонах выдавал себя за математика, звукорежиссёра, радиоведущего, переводчика, писателя. Кандидат наук, но не точных. Бесстрашно пишет о Data Science и программировании на Python.


строк Python


Струны

Строки в Python заключаются в одинарные или двойные кавычки.

«привет» — это то же самое, что «привет».

Вы можете отобразить строковый литерал с помощью функции print () :


Назначить строку переменной

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


Многострочные строки

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

Пример

Можно использовать три двойные кавычки:

a = «» «Lorem ipsum dolor sit amet,
consctetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.»» «
принт (а)

Попробуй сам »

Или три одинарные кавычки:

Пример

a = » ‘Lorem ipsum dolor sit amet,
consctetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. »
print (a)

Попробуй сам »

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

Строки — это массивы

Как и во многих других популярных языках программирования, строки в Python представляют собой массивы байтов, представляющих символы Юникода.

Однако Python не имеет символьного типа данных, одиночный символ — это просто строка длиной 1.

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

Пример

Получить символ в позиции 1 (помните, что первый символ имеет позиция 0):

a = «Привет, мир!»
отпечаток (a [1])

Попробуй сам »

Цикл по строке

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

Пример

Прокрутите буквы в слове «банан»:

для x в «банане»:
print (x)

Попробуй сам »

Узнайте больше о циклах For Loops в нашей главе Python For Loops.


Длина строки

Чтобы получить длину строки, используйте функцию len () .

Пример

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

a = «Привет, мир!»
печать (len (a))

Попробуй сам »

Контрольная строка

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

Пример

Проверьте, присутствует ли слово «бесплатно» в следующем тексте:

txt = «Все самое лучшее в жизни — бесплатно!»
print («бесплатно» в txt)

Попробуй сам »

Используйте его в заявлении if :

Пример

Печатать только при наличии «бесплатно»:

txt = «Все самое лучшее в жизни — бесплатно!»
если «бесплатно» в txt:
print («Да, присутствует» бесплатный «.»)

Попробуй сам »

Узнайте больше об операторах If в нашем Python Если…Эта глава.


Проверить, НЕ

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

Пример

Проверьте, НЕ присутствует ли «дорого» в следующем тексте:

txt = «Все самое лучшее в жизни — бесплатно!»
print («дорого» не в txt)

Попробуй сам »

Используйте его в заявлении if :

Пример

печатать только если «дорого» НЕТ:

txt = «Все самое лучшее в жизни — бесплатно!»
если «дорого» нет в txt:
print («Нет,» дорого «НЕТ.»)

Попробуй сам »

Строка Python — GeeksforGeeks

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

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

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

Python3

String1 = «Добро пожаловать в мир гиков»

print ( "String с использованием одинарных кавычек:" )

print (String1)

String1 = «Я компьютерщик»

print ( "\ nString с использованием двойных кавычек:" )

print (String1)

String1 =

print ( "\ nString с использованием Triple Quotes:" )

print (Строка1)

Строка1 =

print ( "\ nСоздание многострочной строки:" )

print (String1)

Вывод:

 String с использованием одинарных кавычек:
Добро пожаловать в мир компьютерных фанатов

Строка с использованием двойных кавычек:
Я компьютерщик

Строка с использованием тройных кавычек:
Я компьютерщик и живу в мире "компьютерщиков"

Создание многострочной строки:
Компьютерщики
            Для
            Life 

Доступ к символам в Python

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

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



Python3

String1 = "GeeksForGeeks"

print ( "Initial String:" 911 ) (String1)

print ( "\ nПервый символ строки:" )

print (String1 [ 0 ])

print ( "\ nПоследний символ строки:" )

print (String1 [ - 1 ])

Выход:

 Начальная строка:
GeeksForGeeks

Первый символ строки:
грамм

Последний символ строки:
s 

Нарезка строки

Для доступа к диапазону символов в строке используется метод нарезки.Нарезка строки выполняется с помощью оператора нарезки (двоеточие).

Python3

String1 = "GeeksForGeeks"

print ( "Initial String:" )

print

печать ( "\ nРазрезание символов от 3 до 12:" )

печать (String1 [ 3 : 12 ])

печать ( "\ nРазрезание символов между" +

"3-й и 2-й последний символ:" )

печать (String1 [ 3 : - 2 ])

Выход:

 Начальная строка:
GeeksForGeeks

Нарезка символов от 3 до 12:
ksForGeek

Разделение символов между 3-м и 2-м последним символом:
ksForGee 

Удаление / обновление из строки

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

Обновление персонажа:

Python3

String1 = «Привет, я компьютерщик»

print ( "Начальная строка:" )

печать (String1)

String1 [ 2 ] = 'p'

print ( "\ n Обновляющий символ на втором Индекс: " )

печать (String1)

Ошибка:

Отслеживание (последний звонок последний):
Файл" / home / 360bb1830c83a918fc78aa397.py ”, строка 10, в
String1 [2] = 'p'
TypeError: объект 'str' не поддерживает присвоение элемента

Обновление всей строки:

Python3

String1 = «Привет, я компьютерщик»

print ( «Начальная строка:» )

print (String1)

String1 = «Добро пожаловать в мир компьютерщиков»

print ( "\ nОбновленная строка:" )

print (String1)

Выход:


 Начальная строка:
Привет я компьютерщик

Обновленная строка:
Добро пожаловать в мир компьютерщиков 
Удаление символа:

Python3

String1 = «Привет, я компьютерщик»

print ( " Начальная строка: " )

print (String1)

del String1 [ 2 ]

print ( " \ n Удаление символа на втором Индекс: « )

print (String1)

Ошибка:

Отслеживание (последний звонок последний):
Файл« / home / 499e96a61e19944e7e1245b7a.py », строка 10, в
del String1 [2]
TypeError: объект« str »не поддерживает удаление элемента

Удаление всей строки:

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

Python3

String1 = «Привет, я компьютерщик»

print ( «Начальная строка:» )

print (String1)

del String1

print ( "\ n Удаление всей строки:" )

print (String1)

Ошибка:

Отслеживание (последний звонок последним):
Файл «/ home / e4b8f2170f140da99d2fe57d9d8c6a94.py ”, строка 12, в
print (String1)
NameError: имя 'String1' не определено

Escape Sequencing в Python

При печати строк в одинарных и двойных кавычках это вызывает SyntaxError , потому что String уже содержит Single и двойные кавычки и, следовательно, не могут быть напечатаны с использованием любого из них. Следовательно, для печати такой строки используются либо тройные кавычки, либо escape-последовательности для печати таких строк.

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

Python3

String1 =

print ( "Начальная строка с использованием тройных кавычек:" )

print (String1

String1 = 'I \' ma "Geek" '

print ( "\ nЭкранирование одинарной кавычки:" )

print (String1)

String1 = "Я \" Компьютерщик \ ""

печать ( "\ nЭкранирование двойных кавычек:" )

печать (String1)

String1 = "C: \\ Python \\ Geeks \\"

print ( "\ nЭкранирование обратной косой черты:" 900 10)

print (String1)

Вывод:

 Начальная строка с использованием тройных кавычек:
Я компьютерщик

Экранирование одинарной кавычки:
Я компьютерщик

Избегание двойных кавычек:
Я компьютерщик

Экранирование обратной косой черты:
C: \ Python \ Geeks \ 

Чтобы игнорировать escape-последовательности в строке, используется r или R , это означает, что строка является необработанной строкой и escape-последовательности внутри нее следует игнорировать.

Python3

String1 = "Это \ x47 \ x65 \ x65 \ x6b \ x73 in \ x48 \ x45 \ x58"

print ( "\ nПечать в HEX с использованием Escape Sequences: « )

print (String1)

String1 = r » Это \ x47 \ x65 \ x65 \ x6b \ x73 in \ x48 \ x45 \ x58 "

print ( " \ nПечать необработанной строки в формате HEX: " )

print (String1)

Вывод:


 Печать в HEX с использованием escape-последовательностей:
Это выродки в HEX

Печать необработанной строки в формате HEX:
Это \ x47 \ x65 \ x65 \ x6b \ x73 in \ x48 \ x45 \ x58 

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

Строки в Python могут быть отформатированы с использованием метода format (), который является очень универсальным и мощным инструментом для форматирования. Струны.Метод Format в String содержит фигурные скобки {} в качестве заполнителей, которые могут содержать аргументы в соответствии с позицией или ключевым словом для указания порядка.

Python3

String1 = "{} {} {}" . формат ( "Компьютерщики" , "Для" , "Жизнь" )

печать ( "Печать строки в порядке по умолчанию:" )

печать (String1)

String1 = "{1} {0} {2}" . формат ( 'Компьютерщики' , 'Для' , 'Жизнь' )

печать ( "\ nПечать строки в позиционном порядке:" )

печать (String1)

String1 = "{l} {f} {g}" . формат (g = 'Компьютерщики' , f = 'Для' , l = 'Life' )

print ( "\ nПечать строки в порядке ключевых слов:" )

печать (String1)

Вывод:

 Печать строки в порядке по умолчанию:
Компьютерщики на всю жизнь

Строка печати в позиционном порядке:
Для компьютерных фанатов

Печатать строку в порядке ключевых слов:
Life For Geeks 

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

Python3

String1 = "{0: b}" . формат ( 16 )

печать ( "\ nДвоичное представление 16 - это" )

печать (String1)

String1 = "{0: e}" . формат ( 165.6458 )

печать ( "\ nЭкспонентное представление 165.6458 составляет" )

печать (String1)

= "{0: .2f}" . формат ( 1 / 6 )

печать ( "\ none-sixth is:" )

print (String1)

Выход:

 Двоичное представление 16
10000

Экспонентное представление 165.16} была основана в {1: <4}! " .   формат   ( " GeeksforGeeks " ,   2009  )  

печать (String1)

Вывод:

 Выравнивание по левому, центральному и правому краям с форматированием:
| Компьютерщики | для | Компьютерщики |

 GeeksforGeeks была основана в 2009 году! 

Форматирование в старом стиле было выполнено без использования метода форматирования с использованием оператора %

Python3

Integer1 = 12.3456789

print ( "Форматирование в формате 3.2f:" )

print ( 'Значение Integer1% 3.2f' % Integer1)

print ( "\ nФорматирование в формате 3.4f:" )

print ( 'Значение Integer1% 3.4f' % Integer1)

Вывод:

 Форматирование в 3.Формат 2f:
Значение Integer1 - 12,35.

Форматирование в формате 3.4f:
Значение Integer1 равно 12,3457 

Полезные строковые операции

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

Встроенная функция Описание
string.ascii_letters константы верхнего регистра и константы нижнего регистра_константы asppercatterii.
string.ascii_lowercase Объединение строчных букв
строка.ascii_uppercase Объединение заглавных букв
string.digits Цифра в строках
string.hexdigits Шестнадцатеричные цифры в строках
строчные буквы
строчные буквы строка 6 string.lowercase Строка должна содержать строчные буквы.
string.octdigits Octadigit in a string
string.пунктуация символов ASCII, имеющих знаки пунктуации.
string.printable Строка символов, которые можно распечатать
String.endswith () Возвращает True, если строка заканчивается заданным суффиксом, в противном случае возвращает False
String.startswith () Возвращает True, если строка начинается с данного префикса, в противном случае возвращает False
String.isdigit () Возвращает «True», если все символы в строке являются цифрами. В противном случае возвращается «False».
String.isalpha () Возвращает «Истина», если все символы в строке являются алфавитными, в противном случае возвращает «Ложь».
string.isdecimal () Возвращает истину, если все символы в строке десятичные.
str.format () один из методов форматирования строк в Python3, который допускает множественные подстановки и форматирование значений.
String.index Возвращает позицию первого вхождения подстроки в строку
строка.верхний регистр Строка должна содержать буквы верхнего регистра.
string.whitespace Строка, содержащая все символы, которые считаются пробелами.
string.swapcase () Метод преобразует все символы верхнего регистра в нижний регистр и наоборот данной строки и возвращает ее
replace () возвращает копию строки, в которой все вхождения подстроки заменяется другой подстрокой.
Устаревшие строковые функции
Встроенная функция Описание
string.Isdecimal Возвращает истину, если все символы в строке являются десятичными 75 um 75 um Возвращает истину, если все символы в данной строке буквенно-цифровые.
string.Istitle Возвращает True, если строка является строкой с заглавными буквами
String.partition разбивает строку при первом появлении разделителя и возвращает кортеж.
String.Isidentifier Проверяет, является ли строка допустимым идентификатором.
String.len Возвращает длину строки.
String.rindex Возвращает наивысший индекс подстроки внутри строки, если подстрока найдена.
String.Max Возвращает наивысший алфавитный символ в строке.
String.min Возвращает минимальный алфавитный символ в строке.
String.splitlines Возвращает список строк в строке.
string.capitalize Возвращает слово с заглавной буквой первого символа.
string.expandtabs Развернуть табуляторы в строке, заменяя их одним или несколькими пробелами
string.find Возвращает наименьшую индексацию подстроки.
string.rfind найти самый высокий индекс.
string.count Возвращает количество (неперекрывающихся) вхождений подстроки sub в строке
string.lower Возвращает копию s, но с прописными буквами, преобразованными в нижний регистр.
string.split Возвращает список слов строки, если необязательный второй аргумент sep отсутствует или None
string.rsplit () Возвращает список слов строки s, просматривая s с конца.
rpartition () Метод разбивает заданную строку на три части
string.splitfields Возвращает список слов строки, если используется только с двумя аргументами.
string.join Объедините список или кортеж слов с промежуточными вхождениями sep.
string.strip () Возвращает копию строки с удаленными начальными и конечными пробелами
строка.lstrip Вернуть копию строки с удаленными начальными пробелами.
string.rstrip Возвращает копию строки с удаленными конечными пробелами.
string.swapcase Преобразует буквы нижнего регистра в верхний регистр и наоборот.
string.translate Переведите символы с помощью таблицы
string.upper строчные буквы преобразованы в верхний регистр.
string.ljust выровнять по левому краю в поле заданной ширины.
string.rjust Выровнять по правому краю в поле заданной ширины.
string.center () Выровнять по центру в поле заданной ширины.
string-zfill Дополняет числовую строку слева нулевыми цифрами до достижения заданной ширины.
string.replace Возвращает копию строки s со всеми вхождениями старой подстроки, замененной на новую.
string.casefold () Возвращает строку в нижнем регистре, которую можно использовать для сравнения без регистра.
string.encode Кодирует строку в любую кодировку, поддерживаемую Python. Кодировка по умолчанию - utf-8.
string.maketrans Возвращает таблицу перевода, используемую для str.translate ()

Последние статьи о Python String

Больше видео на Python :
Строковые методы Python - Часть 2
Строковые методы Python - Часть 3
Логические операции и разбиение в строках

Программы строк Python

Внимание, компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

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


Python Strings | Обучение Python | Разработчики Google

Python имеет встроенный строковый класс с именем «str» со многими удобными функциями (есть более старый модуль с именем «string», который вам не следует использовать). Строковые литералы могут быть заключены в двойные или одинарные кавычки, хотя чаще используются одинарные кавычки.Экраны с обратной косой чертой работают обычным образом как в литералах с одинарными, так и в двойных кавычках - например, \ n \ '\ ". Строковый литерал в двойных кавычках может содержать одинарные кавычки без всякой суеты (например,« Я этого не делал »), а аналогичная строка в одинарных кавычках может содержать двойные кавычки. Строковый литерал может охватывать несколько строк, но есть должен быть обратной косой чертой \ в конце каждой строки, чтобы избежать новой строки. Строковые литералы в тройных кавычках, "" "или '' ', могут охватывать несколько строк текста.

Строки Python являются «неизменяемыми», что означает, что они не могут быть изменены после создания (строки Java также используют этот неизменяемый стиль).Поскольку строки не могут быть изменены, мы создаем * новые * строки по мере представления вычисленных значений. Так, например, выражение ('hello' + 'there') принимает две строки hello и there и строит новую строку hellothere.

Доступ к символам в строке можно получить с помощью стандартного синтаксиса [], и, подобно Java и C ++, Python использует индексирование с отсчетом от нуля, поэтому, если s равно 'hello' s [1] равно 'e'. Если индекс выходит за пределы строки, Python выдает ошибку. Стиль Python (в отличие от Perl) заключается в том, чтобы остановиться, если он не может сказать, что делать, а не просто создать значение по умолчанию.Удобный синтаксис «среза» (см. Ниже) также позволяет извлекать любую подстроку из строки. Функция len (строка) возвращает длину строки. Синтаксис [] и функция len () на самом деле работают с любым типом последовательности - строками, списками и т. Д. Python пытается заставить свои операции работать согласованно для разных типов. У новичка в Python: не используйте «len» в качестве имени переменной, чтобы не блокировать функцию len (). Оператор '+' может объединять две строки. Обратите внимание на то, что в приведенном ниже коде переменные не объявлены заранее - просто назначьте их и приступайте.

  s = 'привет'
  печать s [1] ## i
  распечатать len (s) ## 2
  напечатайте s + 'там' ## привет там
 

В отличие от Java, знак «+» не преобразует автоматически числа или другие типы в строковую форму. Функция str () преобразует значения в строковую форму, чтобы их можно было комбинировать с другими строками.

  пи = 3,14
  ## text = 'Значение пи' + pi ## НЕТ, не работает
  text = 'Значение пи' + str (pi) ## да
 

Для чисел стандартные операторы +, /, * работают как обычно.Оператора ++ нет, но работают + =, - = и т.д. Если вы хотите целочисленное деление, правильнее всего использовать две косые черты - например, 6 // 5 равно 1 (до python 3 в любом случае одиночное / делает деление int на int, но движение вперед // является предпочтительным способом указать, что вы хотите деление int.)

Оператор print выводит на печать один или несколько элементов Python, за которыми следует новая строка (оставьте запятую в конце элементов, чтобы запретить перевод строки). "Необработанный" строковый литерал имеет префикс 'r' и пропускает все символы без специальной обработки обратных косых черт, поэтому r'x \ nx 'оценивается как строка длины 4' x \ nx '.Префикс «u» позволяет вам писать строковый литерал Unicode (Python имеет множество других функций поддержки Unicode - см. Документацию ниже).

  raw = r 'это \ t \ n и это'

  # это \ t \ n и это
  печать в сыром виде

  multi = "" "Это были лучшие времена.
  Это было худшее из времен "" "

  # Это были лучшие времена.
  # Это были худшие времена.
печать мульти
 

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

Вот некоторые из наиболее распространенных строковых методов. Метод похож на функцию, но он запускается «на» объекте.Если переменная s является строкой, то код s.lower () запускает метод lower () для этого строкового объекта и возвращает результат (эта идея метода, работающего на объекте, является одной из основных идей, составляющих Object Ориентированное программирование, ООП). Вот некоторые из наиболее распространенных строковых методов:

  • s.lower (), s.upper () - возвращает строчную или прописную версию строки
  • s.strip () - возвращает строку с удаленными пробелами в начале и в конце
  • с.isalpha () / s.isdigit () / s.isspace () ... - проверяет, все ли строковые символы находятся в различных классах символов
  • s.startswith ('other'), s.endswith ('other') - проверяет, начинается ли строка или заканчивается заданной другой строкой
  • s.find ('other') - ищет указанную другую строку (не регулярное выражение) в s и возвращает первый индекс, с которого она начинается, или -1, если не найдено
  • s.replace ('old', 'new') - возвращает строку, в которой все вхождения 'old' были заменены на 'new'.
  • с.split ('delim') - возвращает список подстрок, разделенных заданным разделителем. Разделитель - это не регулярное выражение, это просто текст. 'aaa, bbb, ccc'.split (', ') -> [' aaa ',' bbb ',' ccc ']. В качестве удобного особого случая s.split () (без аргументов) разбивается на все пробельные символы.
  • s.join (list) - противоположно split (), объединяет элементы в данном списке вместе, используя строку в качестве разделителя. например '---'. join (['aaa', 'bbb', 'ccc']) -> aaa --- bbb --- ccc

Поиск в Google по запросу "python str" должен привести вас к официальному python.org строковые методы, в которых перечислены все методы str.

Python не имеет отдельного символьного типа. Вместо этого выражение, подобное s [8], возвращает строку длиной-1, содержащую символ. С этой строкой-1 операторы ==,

Ломтики струн

Синтаксис «slice» - удобный способ ссылаться на части последовательностей - обычно строки и списки. Срез s [начало: конец] - это элементы, начинающиеся с начала и продолжающиеся до конца, но не включая его. Предположим, у нас есть s = "Hello"

  • s [1: 4] - это 'ell' - символы, начинающиеся с индекса 1 и продолжающиеся до индекса 4, но не включая его.
  • s [1:] - это 'ello' - без указания значений индекса по умолчанию до начала или конца строки
  • s [:] - это 'Hello' - исключение обоих всегда дает нам копию целого (это питонический способ скопировать последовательность, такую ​​как строка или список)
  • s [1: 100] - это 'ello' - слишком большой индекс усекается до длины строки

Стандартные отсчитываемые от нуля порядковые номера обеспечивают легкий доступ к символам в начале строки.В качестве альтернативы Python использует отрицательные числа для облегчения доступа к символам в конце строки: s [-1] - последний символ 'o', s [-2] - 'l' предпоследний char и так далее. Отрицательные номера индекса отсчитываются от конца строки:

  • s [-1] is 'o' - последний символ (первый с конца)
  • с [-4] - это 'e' - четвертая с конца
  • s [: - 3] - это «Он» - идет до последних трех символов, но не включая их.
  • s [-3:] - это 'llo' - начиная с 3-го символа от конца и до конца строки.

Это чистый трюизм срезов, что для любого индекса n s [: n] + s [n:] == s . Это работает даже при отрицательном n или за пределами допустимого значения. Или, по-другому, s [: n] и s [n:] всегда разделяют строку на две части, сохраняя все символы. Как мы увидим позже в разделе списков, срезы тоже работают со списками.

Строка%

Python имеет похожее на printf () средство для объединения строк. Оператор% принимает строку формата типа printf слева (% d int,% s строка,% f /% g с плавающей запятой) и соответствующие значения в кортеже справа (кортеж состоит из значений, разделенных символом запятые, обычно сгруппированные в круглых скобках):

  #% оператор
  text = "% d поросят вылезут, или я% s, я% s, и я взорву ваш% s."% (3, 'huff', 'puff', 'house')
 

Вышеупомянутая строка довольно длинная - предположим, вы хотите разбить ее на отдельные строки. Вы не можете просто разделить строку после символа «%», как в других языках, поскольку по умолчанию Python обрабатывает каждую строку как отдельный оператор (с положительной стороны, вот почему нам не нужно вводить точки с запятой для каждого линия). Чтобы исправить это, заключите все выражение в круглые скобки - тогда выражение может занимать несколько строк. Этот метод сквозного кода работает с различными конструкциями группирования, подробно описанными ниже: (), [], {}.

  # Добавьте круглые скобки, чтобы длинная строка работала:
  текст = (
    «Вылезут% d поросят, или я% s, я% s, и я взорву ваш% s».
    % (3, 'фырка', 'затяжка', 'хаус'))
 

Так и лучше, но очередь все равно длинновата. Python позволяет разрезать строку на части, которые затем автоматически объединяются. Итак, чтобы сделать эту строку еще короче, мы можем сделать это:

  # Разбиваем строку на куски, которые автоматически объединяются Python
  текст = (
    "% d поросят вышли",
    "или я% s, и я% s,"
    "и я взорву твой% s."
    % (3, 'фырка', 'затяжка', 'хаус'))
 

Строки i18n (Unicode)

Обычные строки Python * не * unicode, это просто байты. Чтобы создать строку Unicode, используйте префикс u в строковом литерале:

> ustring = u'A unicode \ u018e string \ xf1 '
> ustring
u'A unicode \ u018e строка \ xf1 '
 

Строка Юникода - это объект другого типа, чем обычная строка "str", но строка Юникода совместима (они используют общий суперкласс "basestring"), и различные библиотеки, такие как регулярные выражения, работают правильно, если вместо этого передается строка Юникода. обычной строки.

Чтобы преобразовать строку Юникода в байты с кодировкой, такой как 'utf-8', вызовите метод ustring.encode ('utf-8') для строки Юникода. В другом направлении функция unicode (s, encoding) преобразует закодированные простые байты в строку Unicode:

## (ustring сверху содержит строку Unicode)
> s = ustring.encode ('utf-8')
> с
'Строка Unicode \ xc6 \ x8e \ xc3 \ xb1' ## байтов в кодировке utf-8
> t = unicode (s, 'utf-8') ## Преобразование байтов обратно в строку Unicode
> t == ustring ## Он такой же, как оригинал, ура!
 

Правда

Встроенная функция печати не полностью работает со строками Unicode.Вы можете сначала encode () печатать в utf-8 или что-то еще. В разделе чтения файлов есть пример, который показывает, как открыть текстовый файл с некоторой кодировкой и прочитать строки Unicode. Обратите внимание, что обработка Unicode - это одна из областей, в которой Python 3 значительно очищен по сравнению с поведением Python 2.x, описанным здесь.

Если заявление

Python не использует {} для включения блоков кода для if / loops / function и т. Д. Вместо этого Python использует двоеточие (:) и отступы / пробелы для группировки операторов.Логический тест для if не обязательно должен быть в скобках (большое отличие от C ++ / Java), и он может иметь предложения * elif * и * else * (мнемоника: слово «elif» имеет ту же длину, что и слово « еще").

Любое значение может использоваться как if-test. Все «нулевые» значения считаются ложными: нет, 0, пустая строка, пустой список, пустой словарь. Существует также логический тип с двумя значениями: True и False (преобразованный в int, это 1 и 0). Python имеет обычные операции сравнения: ==,! =, <, <=,>,> =.В отличие от Java и C, == перегружен для правильной работы со строками. Логические операторы - это прописанные слова * и *, * или *, * not * (Python не использует C-стиль && ||!). Вот как может выглядеть код, если полицейский тянет спидер - обратите внимание, как каждый блок операторов then / else начинается с:, а операторы сгруппированы по их отступам:

  если скорость> = 80:
    распечатать 'Лицензия и регистрация, пожалуйста'
    если настроение == 'ужасное' или скорость> = 100:
      print 'Вы имеете право хранить молчание.'
    elif mood == 'bad' или speed> = 90:
      print "Мне придется выписать вам билет".
      write_ticket ()
    еще:
      print "Давай попробуем сохранить меньше 80, ладно?"
 

Я считаю, что пропуск ":" является моей самой распространенной синтаксической ошибкой при вводе кода вышеупомянутого типа, вероятно, потому, что это дополнительная вещь, которую нужно набирать по сравнению с моими привычками C ++ / Java. Кроме того, не помещайте логический тест в скобки - это привычка C / Java. Если код короткий, вы можете поместить его в ту же строку после ":", как это (это относится к функциям, циклам и т. Д.также), хотя некоторые люди считают, что удобнее размещать элементы в отдельных строках.

  если скорость> = 80: print 'Вы так разорились'
  else: print "Хорошего дня"
 

Упражнение: string1.py

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

Python String Tutorial - DataCamp

String - это набор алфавитов, слов или других символов. Это одна из примитивных структур данных, которые служат строительными блоками для манипулирования данными.Python имеет встроенный строковый класс с именем str . Строки Python являются «неизменяемыми», что означает, что они не могут быть изменены после создания. Для обработки строк мы создаем новые строки по мере представления вычисленных значений из-за их неизменяемого свойства.

В этом руководстве вы подробно ознакомитесь со строками и охватите следующие темы:

Если вам интересно узнать больше о структурах данных в Python, обязательно ознакомьтесь с набором инструментов Python Data Science Toolbox, состоящим из двух частей.Этот курс более подробно описывает функции, итераторы, списки и т. Д.

Струны

Вы можете обрабатывать текстовые данные в Python с помощью объекта str . Строки - это неизменяемые последовательности юникода . Юникод - это система, предназначенная для представления всех символов языков. В Юникоде каждая буква, символ представлена ​​как 4-байтовое число. Каждое число представляет собой уникальный символ.

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

  • Одиночные кавычки, как в этом примере: 'Одиночные кавычки позволяют вставлять «двойные» кавычки в вашу строку.'
  • Двойные кавычки. Например: «Двойные кавычки позволяют вставлять в строку« одинарные »кавычки».
  • Тройные кавычки, как в этом примере: "" "Тройные кавычки с использованием двойных кавычек" "" '' 'Тройные кавычки с использованием одинарных кавычек.' ''

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

  single_quote = 'Одиночные кавычки позволяют вставлять "двойные" кавычки в вашу строку.'
double_quote = "Двойные кавычки позволяют вставлять" одинарные "кавычки в вашу строку."
triple_quote = "" "Тройные кавычки позволяют вставлять« двойные кавычки », а также« одинарные кавычки »в вашу строку.
А также может занимать несколько строк. "" "
  

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

  triple_quote = '' 'Это строка в тройных кавычках с использованием "одинарных" кавычек.' ''
triple_quote [35] = "'"
  
  ------------------------------------------------ ---------------------------

TypeError Traceback (последний вызов последним)

 в  ()
      1 triple_quote = '' 'Это строка в тройных кавычках с использованием «одинарных» кавычек.'' '
----> 2 triple_quote [35] = "'"


TypeError: объект 'str' не поддерживает назначение элементов
  
  triple_quote_new = triple_quote [0:35] + "single" "+ triple_quote [43:]
печать (triple_quote_new)
  
  Это строка в тройных кавычках с использованием «одинарных» кавычек.
  

Вы можете узнать длину строки с помощью встроенной функции len () :

  лен (triple_quote_new)
  
  51
  

Нарезка строки в Python

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

.

В приведенной выше строке первый индекс - C , и он проиндексирован 0. Последний символ - это точка . , который является 16-м символом в строке. Вы также можете получить доступ к символам в противоположном направлении, начиная с -1, что означает, что вы также можете использовать -1 в качестве значения индекса для доступа к . в строке. Также есть пробел между Chocolate и cookie , он также является частью строки и имеет свой собственный индекс, в данном случае 9-й.Вы можете проверить это с помощью нарезки.

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

  snake = "Шоколадное печенье."
печать (закуска [0])
печать (закуска [9])
печать (закуска [-1])
  
  С

.
  

Предположим, вы хотите извлечь подстроку cookie из приведенной ниже строки. Как бы ты это сделал?

В таких случаях используется нарезка диапазона.

Синтаксис для разделения диапазона следующий: [Начальный индекс (включен): Конечный индекс (исключен)]

  snake = "Шоколадное печенье."
печать (закуска [10:16])
  
  печенье
  

Вы также можете сделать это, используя отрицательное значение для стоп-индекса:

  print (snake [10: -1]) # -1: поскольку стоп-индекс исключен из нарезки. 
  печенье
  

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

  # Stop value не указан
печать (закуска [0:])

# Начальное значение не указано (конечное значение исключено в соответствии с синтаксисом)
печать (закуска [: - 1])

# Это также разрешено
печать (закуска [:])
  
  Шоколадное печенье.Шоколадное печенье
Шоколадное печенье.
  

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

Давайте посмотрим на stride в действии, чтобы лучше понять:

  number_string = "1020304050"
печать (строка_числа [0: -1: 2])
  
  12345
  

Совет : Кое-что, очень крутое, что вы можете сделать с шагом, - это перевернуть строку:

  print (number_string [:: - 1]) #
  
  0504030201
  

Значение -1 для шага позволяет вам начать с конечного символа и затем перемещать по одному символу за раз.

В качестве альтернативы, если вы указываете -2 в качестве значения, вы начинаете с конечного символа и перемещаете два символа за раз:

  print (number_string [:: - 2]) #
  
  00000
  

Общие строковые операции

Нарезка, нарезка по диапазону - это обычные операции, которые вам нужно будет выполнить со строками. Также существует конкатенация строк, которая так же проста, как сложение:

  string1 = "Шоколад"
строка2 = 'cookie'

снек = строка1 + "" + строка2
печать (закуска)
  
  Шоколадное печенье
  

Однако это не сработает, если вы попытаетесь объединить строку с каким-либо другим типом данных.

  стоимость = 15
string1 = "Общая сумма в евро:"

счет = строка1 + стоимость
распечатать (счет)
  
  ------------------------------------------------ ---------------------------

TypeError Traceback (последний вызов последним)

 в  ()
      2 string1 = "Итого в евро:"
      3
----> 4 счет = строка1 + стоимость
      5 оттиск (счет)


TypeError: невозможно неявно преобразовать объект int в str
  

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

  счет = строка1 + строка (стоимость)
распечатать (счет)
  
  Итого в евро: 15
  

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

Чтобы повторить строку, используйте операцию * .

  single_word = 'бедро'
line1 = single_word * 2 + 'ура! '
печать (строка1 * 3)
  
  бедра, ура! бедра бедра ура! бедра бедра ура!
  

Вы также можете проверить свойство принадлежности в строке, используя в и не в :

  sub_string1 = 'лед'
sub_string2 = 'клей'
строка1 = 'мороженое'
если sub_string в строке1:
    print ("Есть" + sub_string + "in" + string1)
если sub_string2 отсутствует в строке1:
    print ("Уф! Нет" + sub_string2 + "in" + string1)
  
  В мороженом есть лед
Уф! Без клея в мороженом
  

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

Взгляните на некоторые из них подробнее:

  • str.capitalize () : возвращает копию строки с заглавными буквами первого символа.
  str.capitalize ('cookie')
  
  «Печенье»
  
  • str.islower () : возвращает true, если все символы в строке строчные, иначе false.
  снек = "печенье"
Snack.islower ()
  
  Правда
  
  • str.find (подстрока) : возвращает наименьший индекс в строке, в которой найдена подстрока. Вы также можете указать начальный и конечный индексы в строке, где вы хотите, чтобы подстрока искалась. Возвращает -1, если подстрока не найдена.
  str1 = 'Я принес тебе печенье'
str2 = 'готовить'
str1.find (str2)
  
  12
  
  • ул.count (substring) : подсчитывает, сколько раз подстрока встречается в строке. Вы также можете указать начальный и конечный индекс для строки.
  str1 = 'Я принес тебе печенье, ты любишь печенье?'
str2 = 'cookie'
str1.count (str2)
  
  2
  
  • str.isspace () : возвращает Истина , если в строке есть только пробельные символы, в противном случае - false. Пробельные символы - это такие символы, как пробел, табуляция, следующая строка и т. Д.

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

  str_space = ''
str_space.isspace ()
  
  Правда
  
  str_tab = '\ t'
str_tab.isspace ()
  
  Правда
  
  str_nextline = '' '\ n' ''
str_nextline.isspace ()
  
  Правда
  

Примечание : Вы заметили \ t , \ n выше? Они называются escape-символами .Они начинаются с \ (обратная косая черта). Внутри они не интерпретируются как обычные строки, а скорее как специальные символы, которые представляют что-то еще. Например - \ t представляет вкладку. Есть еще много escape-символов, и вы можете прочитать о них здесь.

  • str.lstrip () : удаляет все ведущие пробелы в строке. Это еще одна функция, которая может оказаться полезной при работе с реальными наборами данных.
  str1 = "Я вас не слышу.Ты в порядке? "
str2 = "Да, все хорошо."
str3 = str1.lstrip () + str2.lstrip ()
печать (str3)
  
  Я вас не слышу. Ты в порядке? Да все хорошо.
  
  • str.isdigit () : возвращает True , если строка содержит только цифры, и False в противном случае.
  number_string = "1020304050"
number_string.isdigit ()
  
  Правда
  
  • str.replace (substring, new) : заменяет все вхождения подстроки в строке на новую.Вы также можете определить третий аргумент max , который заменяет не более max вхождений подстроки в строке. Помните, что это не замена на месте, что означает, что неизменяемое свойство все еще сохраняется, и фактически формируется новая строка.
  string1 = 'Ура! бедра бедра ура! бедра бедра ура! '
строка2 = строка1.replace ('бедро', 'бедро')
печать (строка1)
печать (строка2)
  
  бедра, ура! бедра бедра ура! бедра бедра ура!
Хип Хип ура! Хип Хип ура! Хип Хип ура!
  
  строка1.replace ('бедро', 'бедро', 2)
  
  'Hip Hip ура! бедра бедра ура! бедра бедра ура! '
  
  • str.split (delimiter = "") : разбивает строку в соответствии с разделителем (пробел, если он не указан) и возвращает список подстрок.
  десерт = 'Торт, печенье, мороженое'
list_dessert = строка1.split (',')
  

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

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

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

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

По модулю % - это встроенная операция в Python. Он известен как оператор интерполяции . Вам нужно будет указать % , за которым следует тип данных, который необходимо отформатировать или преобразовать. Затем операция % заменяет фразу "% datatype" на ноль или более элементов указанного типа данных:

  print («Я купил% s на% d евро!»% (200, 'cookies'))
  
  Я купил печенье на 200 евро!
  

Вы видели, что % d используется для целых чисел и % s для строк.Некоторые из других доступных типов преобразования: o для восьмеричных значений, x для шестнадцатеричного, f для десятичного формата с плавающей запятой, c для одиночного символа (принимает целочисленную или односимвольную строку).

Класс форматтера

Модуль форматирования Класс является одним из встроенных строковых классов. Он предоставляет возможность выполнять сложные подстановки переменных и форматирование значений с помощью метода format () . Он позволяет создавать и настраивать собственное поведение форматирования строк путем переписывания содержащихся в нем общедоступных методов: format () , vformat () .В нем есть несколько методов, которые предназначены для замены подклассами: parse () , get_field () , get_value () , check_unused_args () , format_field () и convert_field () . Однако для простоты вы рассмотрите в действии только наиболее часто используемую функцию format () ...

  print ("Я купил {0} евро на сумму {1}!". Format (200, 'cookies')) # Доступ к значениям по позиции
  
  Я купил печенье на 200 евро!
  
  печать («Я купил {item} на сумму {total} евро!».10} '. Format (' Cake ') # Центральное выравнивание для слова' Cake 'в соответствии с выравниванием по правому краю, пробелы заполняются символом' # '
  
  '### Торт ###'
  
  '{: #> 10}'. Format ('Cake') # Правильное выравнивание для слова 'Cake' в соответствии с выравниванием по правому краю, пробелы заполняются символом '#'
  
  '###### Торт'
  
  для числа в диапазоне (1,10):
        print ('{0: {width}}'. format (num, width = 5), end = '')
  
  1 2 3 4 5 6 7 8 9
  

Строки шаблона

Вместо обычных замен на основе % шаблоны поддерживают замены на основе $ .Обоснование введения шаблона в Python версии 2.4 заключалось в том, что даже несмотря на то, что форматирование строк % является мощным и богатым, они подвержены ошибкам, а также довольно строгие с точки зрения форматов, следующих за "%", что делает его сложным. Распространенная ошибка при форматировании % - забыть завершающий символ формата, например: e в % (variabl) e .

В шаблонах

определены некоторые методы: substitute () и safe_substitute () .Вот как их можно использовать:

  из шаблона импорта строк # Сначала вам нужно будет импортировать класс Tempalte

money = dict (who = 'You', to_whom = 'baker')
Шаблон ('$ кто должен $ to_whom в сумме $ 100'). Replace (деньги)
  
  "Вы должны пекарю 100 долларов"
  

Обратите внимание на $$ в приведенном выше примере?

Это связано с тем, что в шаблоне $$ - это escape-символ, который заменяется одним $ .Это одно из правил для шаблона. Еще одно правило для шаблона - это то, как вы определяете идентификатор в своем шаблоне, есть обычный синтаксис: $ идентификатор , но у вас также есть $ {идентификатор} .

Это означает, что $ {идентификатор} совпадает с идентификатором $ , но может использоваться для таких сценариев, как:

  word = dict (существительное = 'кормить')
Шаблон ('Пожалуйста, не останавливай меня, $ {существительное}'). Replace (слово)
  
  «Пожалуйста, не переставай меня кормить»
  

Давайте посмотрим, как можно использовать замену () и safe_substitute () .

  fact = Template ('$ alter_ego слабый, но подождите, пока он превратится в $ superhero!')
fact.substitute (alter_ego = 'Брюс Баннер', superhero = 'Халк')
  
  'Брюс Беннер слаб, но подожди, пока он не превратится в Халка!'
  
  hero = dict (alter_ego = 'Питер Паркер')
факт. заменитель (герой)
  
  ------------------------------------------------ ---------------------------

KeyError Traceback (последний вызов последним)

 в  ()
      1 герой = dict (alter_ego = 'Питер Паркер')
----> 2 факт.заменитель (герой)


~ / anaconda3 / envs / tensorflow / lib / python3.5 / string.py в заменителе (* args, ** kws)
    127 поднять ValueError ('Нераспознанная именованная группа в шаблоне',
    128 самовыражений)
-> 129 вернуть self.pattern.sub (convert, self.template)
    130
    131 def safe_substitute (* аргументы, ** кВт):


~ / anaconda3 / envs / tensorflow / lib / python3.5 / string.py в convert (mo)
    117 named = mo.group ('named') или mo.group ('braced')
    118, если имя не равно None:
-> 119 val = отображение [имя]
    120 # Мы используем эту идиому вместо str (), потому что последняя будет
    121 # ошибка, если val - это Unicode, содержащий символы, отличные от ASCII.KeyError: супергерой
  

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

  fact.safe_substitute (герой)
  
  'Питер Паркер слаб, но подожди, пока он не превратится в супергероя!'
  

safe_substitute () - одно из преимуществ использования шаблона.

Вы спросите, почему так много вариантов форматирования строк?

Ну, это в первую очередь вопрос синтаксических предпочтений.Обычно это сводится к компромиссу между простотой и многословием, а также зависит от вашего знакомства с существующим синтаксисом. Например, использование % для форматирования строк будет казаться естественным людям, имеющим опыт программирования на C. Шаблоны в Python легко писать, тогда как использование format () может быть более подробным, но имеет больше функций.

Форматированный строковый литерал (f-строка)

Это еще один метод форматирования строк, добавленный в Python версии 3.6. Форматированный строковый литерал или f-строка - это строковый литерал с префиксом «f» или «F».Вы можете определить идентификаторы, которые будут использоваться в вашей строке, в фигурных скобках {} .

Зачем нужна еще одна опция форматирования строк? Практичность и простота - это красиво и поэтому!

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

alter_ego = 'Питер Паркер' супергерой = 'человек-паук' f '{alter_ego} слабый, но подождите, пока он не превратится в {superhero}!'

Примечание : приведенный выше код будет работать только с Python версии 3.6 и выше. Чтобы проверить версию установленного Python, введите на терминале: python -V . В противном случае вы также можете использовать модуль sys в Python. Чтобы использовать это, просто сделайте следующее:

  импорт систем
sys.version
  

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

f '{alter_ego} слабый, но подождите, пока он не превратится в {супергероя.capitalize ()}! '

Разве f-string уже не велика! Но подождите, это становится еще лучше ... f-строки также быстрее по сравнению с другими тремя методами, которые вы видели ранее. Это потому, что они предварительно анализируются и сохраняются в эффективном байт-коде для более быстрого выполнения.

Дергайте за правильные струны!

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

Строки - один из нескольких типов данных в Python. Ознакомьтесь с курсом DataCamp Data Types for Data Science, чтобы узнать больше о списках, словарях, кортежах и наборах. В этом курсе вы можете использовать свои знания о типах данных. Вы будете работать с данными о транзите из столичного региона Чикаго в целях анализа данных. Сходите, чтобы убедиться в этом сами ...

Основное руководство по строке Python на практических примерах

Резюме : в этом руководстве вы узнаете о строке Python и ее основных операциях.

Введение в Python string

Строка - это последовательность символов. В Python все, что находится внутри кавычек, является строкой. И вы можете использовать как одинарные, так и двойные кавычки. Например:

 

message = 'Это строка в Python' message = "Это также строка"

Язык кода: Python (python)

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

 

message = "Это строка "

Язык кода: Python (python)

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

 

message = '« Красивое лучше, чем уродливое.Сказал Тима Петерса

Язык кода: Python (python)

Чтобы избежать кавычек, используйте обратную косую черту ( \ ). Например:

 

message = 'Это также допустимая строка '

Язык кода: Python (python)

Интерпретатор Python будет обрабатывать символ обратной косой черты (\) специальным образом. Если вы этого не хотите, вы можете использовать необработанные строки, добавив букву r перед первой цитатой.Например:

 

message = r'C: \ python \ bin '

Язык кода: Python (python)

Создание многострочных строк

Чтобы разбить строку на несколько строк, вы используете тройные кавычки «» »…» »» или «»… »'.Например:

 

help_message = '' ' Использование: команда mysql -h имя хоста -d имя базы данных -u имя пользователя -p пароль '' ' print (help_message)

Язык кода: Python (python)

Если вы запустите программу, он выдаст следующее:

 

Использование: команда mysql -h имя хоста -d имя базы данных -u имя пользователя -p пароль

Язык кода: Python (python)

Использование переменных в строках Python с f-строками

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

Например, вы можете использовать значение переменной name внутри строковой переменной сообщения :

 

name = 'John' message = 'Hi'

Язык кода: Python (python)

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

 

name = ' Джон' message = f'Hi {имя} ' print (message)

Язык кода: Python (python)

Python заменит {name} значением переменной name .Код покажет на экране следующее:

 

Hi John

Язык кода: Python (python)

Сообщение - это строка формата, или коротко f-строка. Python представил f-строку с версии 3.6.

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

Когда вы помещаете строковые литералы рядом друг с другом, Python автоматически объединяет их в одну строку. Например:

 

приветствие = «Доброе утро». печать (приветствие)

Язык кода: Python (python)

Вывод:

 

Доброе утро!

Язык кода: Python (python)

Для объединения двух строковых переменных используется оператор + :

 

welcome = 'Good' time = 'После полудня' приветствие = приветствие + время + '!' печать (приветствие)

Язык кода: Python (python)

Вывод:

 

Добрый день!

Язык кода: Python (python)

Доступ к строковым элементам

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

В следующем примере показано, как получить доступ к элементам с помощью индекса:

 

str = "Python String" печать (str [0]) print (str [1])

Язык кода: Python (python)

Как это работает:

  • Сначала создайте переменную, содержащую строку «Python String» .
  • Затем перейдите к первому и второму символам строки, используя квадратные скобки [] и индексы.

Если вы используете отрицательный индекс, Python возвращает символ, начиная с конца строки. Например:

 

str = "Python String". печать (стр [-1]) print (str [-2])

Язык кода: Python (python)

Ниже показаны индексы строки «Python String» :

 

+ --- + --- + - - + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + | P | y | т | h | о | п | | S | т | г | я | п | г | + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + --- + - - + 0 1 2 3 4 5 6 7 8 9 10 11 12 -12-11-10-9-8-7-6-5-4-3-2-1 0

Язык кода: Python (python)

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

Чтобы получить длину строки вы используете функцию len () .Например:

 

str = "Python String". str_len = len (str) print (str_len)

Язык кода: Python (python)

Вывод:

 

13

Язык кода: Python (python)

Нарезка строк

Нарезка позволяет получить подстроку из нить. Например:

 

str = "Python String". print (str [0: 2])

Язык кода: Python (python)

Вывод:

 

Py

Язык кода: Python (python)

Строка [0: 2] возвращает подстроку, которая включает символ от индекса 0 (включен) до 2 (исключен).

Синтаксис для нарезки следующий:

 

строка [начало: конец]

Язык кода: Python (python)

Подстрока всегда включает символ в начале и исключает строку в конец .

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

Строки Python неизменяемы

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

 

str = "Python String" str [0] = 'J'

Язык кода: Python (python)

Ошибка:

 

Отслеживание (последний вызов последним): Файл "app.py", строка 2, в str [0] = 'J' TypeError: объект 'str' не поддерживает назначение элементов

Язык кода: Python (python)

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

 

str = "Строка Python". new_str = 'J' + str [1:] print (new_str)

Язык кода: Python (python)

Вывод:

 

Jython String

Язык кода: Python (python)

Резюме

  • В Python строка представляет собой серию персонажей. Кроме того, строки Python неизменяемы.
  • Используйте кавычки, одинарные или двойные кавычки для создания строковых литералов.
  • Используйте обратную косую черту \ для экранирования кавычек в строках
  • Используйте необработанные строки r '... ', чтобы избежать символа обратной косой черты.
  • Используйте f-строки для вставки замещающих переменных в буквальные строки.
  • Поместите буквенные строки рядом друг с другом, чтобы объединить их. И используйте оператор + для объединения строковых переменных.
  • Используйте функцию len () , чтобы получить размер строки.
  • Используйте str [n] для доступа к символу в позиции n строки str .
  • Используйте нарезку для извлечения подстроки из строки.

Вы нашли это руководство полезным?

Строки и символьные данные в Python - Real Python

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

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

Вы уже видели операторы + и * , применяемые к числовым операндам в учебнике по операторам и выражениям в Python. Эти два оператора также могут применяться к строкам.

Оператор
+

Оператор + объединяет строки. Он возвращает строку, состоящую из операндов, объединенных вместе, как показано здесь:

>>>
  >>> s = 'foo'
>>> t = 'бар'
>>> u = 'baz'

>>> с + т
'foobar'
>>> с + т + и
'foobarbaz'

>>> print ('Go team' + '!!!')
Вперед, команда !!!
  
Оператор
*

Оператор * создает несколько копий строки.Если s - строка, а n - целое число, любое из следующих выражений возвращает строку, состоящую из n конкатенированных копий s :

с * с
н * с

Вот примеры обеих форм:

>>>
  >>> s = 'foo.'

>>> с * 4
'foo.foo.foo.foo.'
>>> 4 * с
'foo.foo.foo.foo.'
  

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

Если бы вы создали строковую переменную и инициализировали ее пустой строкой, присвоив ей значение 'foo' * -8 , любой справедливо подумал бы, что вы немного глупы. Но это сработает.

в Оператор

Python также предоставляет оператор членства, который можно использовать со строками. Оператор in возвращает True , если первый операнд содержится во втором, и False в противном случае:

>>>
  >>> s = 'foo'

>>> Вот это пища для размышлений.'
Правда
>>> в "Пока все хорошо".
Ложь
  

Также есть не в операторе , который делает наоборот:

>>>
  >>> 'z' не входит в 'abc'
Правда
>>> 'z' не входит в 'xyz'
Ложь
  

Встроенные строковые функции

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

Функция Описание
chr () Преобразует целое число в символ
ord () Преобразует символ в целое число
л. () Возвращает длину строки
ул. () Возвращает строковое представление объекта

Более подробно они рассматриваются ниже.

орд (в)

Возвращает целое число для данного символа.

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

Самая простая из распространенных схем называется ASCII. Он охватывает распространенные латинские символы, с которыми вы, вероятно, привыкли работать. Для этих символов ord (c) возвращает значение ASCII для символа c :

. >>>
  >>> ord ('а')
97
>>> ord ('#')
35 год
  

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

Unicode - амбициозный стандарт, который пытается предоставить числовой код для каждого возможного символа на всех возможных языках и на всех возможных платформах. Python 3 широко поддерживает Юникод, в том числе позволяет использовать символы Юникода в строках.

Пока вы остаетесь в домене общих символов, между ASCII и Unicode мало практических различий. Но функция ord () также вернет числовые значения для символов Юникода:

>>>
  >>> ord ('€')
8364
>>> ord ('∑')
8721
  
chr (н)

Возвращает символьное значение для заданного целого числа.

chr () выполняет обратную операцию ord () .Учитывая числовое значение n , chr (n) возвращает строку, представляющую символ, который соответствует n :

>>>
  >>> chr (97)
'а'
>>> chr (35)
'#'
  

chr () также обрабатывает символы Unicode:

>>>
  >>> chr (8364)
'€'
>>> chr (8721)
'∑'
  

лён (с)

Возвращает длину строки.

С помощью len () вы можете проверить длину строки Python. len (s) возвращает количество символов в s :

>>>
  >>> s = 'Я струна'.
>>> len (s)
14
  

ул. (Объект)

Возвращает строковое представление объекта.

Практически любой объект в Python может быть отображен в виде строки. str (obj) возвращает строковое представление объекта obj :

>>>
  >>> str (49.2)
'49.2 '
>>> str (3 + 4j)
'(3 + 4j)'
>>> ул (3 + 29)
'32'
>>> str ('фу')
'фу'
  

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

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

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

Индексирование строк в Python начинается с нуля: первый символ в строке имеет индекс 0 , следующий - индекс 1 и так далее. Индекс последнего символа будет длиной строки минус один.

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

Строковые индексы

Доступ к отдельным символам можно получить по индексу следующим образом:

>>>
  >>> s = 'foobar'

>>> s [0]
'f'
>>> s [1]
'о'
>>> s [3]
'b'
>>> len (s)
6
>>> s [len (s) -1]
'р'
  

Попытка индексировать за пределами конца строки приводит к ошибке:

>>>
  >>> s [6]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    s [6]
IndexError: строковый индекс вне допустимого диапазона
  

Индексы строки также могут быть указаны с отрицательными числами, и в этом случае индексация выполняется с конца строки назад: -1 относится к последнему символу, -2 - к предпоследнему символу и т. Д.Вот та же диаграмма, показывающая как положительные, так и отрицательные индексы в строке 'foobar' :

. Положительные и отрицательные строковые индексы

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

>>>
  >>> s = 'foobar'

>>> s [-1]
'р'
>>> с [-2]
'а'
>>> len (s)
6
>>> s [-len (s)]
'f'
  

Попытка индексирования с отрицательными числами за пределами начала строки приводит к ошибке:

>>>
  >>> с [-7]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    с [-7]
IndexError: строковый индекс вне допустимого диапазона
  

Для любой непустой строки s , s [len (s) -1] и s [-1] оба возвращают последний символ.Нет никакого индекса, который имел бы смысл для пустой строки.

Нарезка струн

Python также позволяет использовать синтаксис индексации, который извлекает подстроки из строки, известный как нарезка строки. Если s является строкой, выражение вида s [m: n] возвращает часть s , начиная с позиции m и до, но не включая позицию n :

>>>
  >>> s = 'foobar'
>>> s [2: 5]
'оба'
  

Помните: Строковые индексы отсчитываются от нуля.Первый символ в строке имеет индекс 0 . Это относится как к стандартной индексации, так и к нарезке.

Опять же, второй индекс указывает первый символ, который не включен в результат - символ 'r' ( s [5] ) в приведенном выше примере. Это может показаться несколько неинтуитивным, но дает такой результат, который имеет смысл: выражение s [m: n] вернет подстроку длиной n - m символов, в данном случае 5 - 2 = 3 .

Если вы опустите первый индекс, срез начнется в начале строки. Таким образом, s [: m] и s [0: m] эквивалентны:

>>>
  >>> s = 'foobar'

>>> s [: 4]
'фуб'
>>> s [0: 4]
'фуб'
  

Аналогично, если вы опустите второй индекс, как в s [n:] , срез простирается от первого индекса до конца строки. Это хорошая и лаконичная альтернатива более громоздкому s [n: len (s)] :

>>>
  >>> s = 'foobar'

>>> s [2:]
'обар'
>>> s [2: len (s)]
'обар'
  

Для любой строки s и любого целого числа n ( 0 ≤ n ≤ len (s) ) s [: n] + s [n:] будет равно s :

>>>
  >>> s = 'foobar'

>>> s [: 4] + s [4:]
'foobar'
>>> s [: 4] + s [4:] == s
Правда
  

Если пропустить оба индекса, будет полностью возвращена исходная строка.Буквально. Это не копия, это ссылка на исходную строку:

>>>
  >>> s = 'foobar'
>>> t = s [:]
>>> id (s)
59598496
>>> id (t)
59598496
>>> s is t
Правда
  

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

>>>
  >>> s [2: 2]
''
>>> s [4: 2]
''
  

Отрицательные индексы также можно использовать с нарезкой. -1 относится к последнему символу, -2 - предпоследнему и так далее, как и при простой индексации. На диаграмме ниже показано, как вырезать подстроку 'oob' из строки 'foobar' , используя как положительные, так и отрицательные индексы:

Нарезка строки с положительными и отрицательными индексами

Вот соответствующий код Python:

>>>
  >>> s = 'foobar'

>>> s [-5: -2]
'oob'
>>> s [1: 4]
'oob'
>>> s [-5: -2] == s [1: 4]
Правда
  

Указание шага в срезе строки

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

Например, для строки 'foobar' фрагмент 0: 6: 2 начинается с первого символа и заканчивается последним символом (всей строкой), и каждый второй символ пропускается. Это показано на следующей диаграмме:

Индексирование строки с помощью Stride

Аналогично, 1: 6: 2 определяет фрагмент, начинающийся со второго символа (индекс 1 ) и заканчивающийся последним символом, и снова значение шага 2 заставляет пропускать все остальные символы. :

Другая строковая индексация с помощью Stride

Пример кода REPL показан здесь:

>>>
  >>> s = 'foobar'

>>> s [0: 6: 2]
'foa'

>>> s [1: 6: 2]
'obr'
  

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

>>>
  >>> s = '12345' * 5
>>> с
'1234512345123451234512345'
>>> s [:: 5]
'11111'
>>> s [4 :: 5]
'55555'
  

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

>>>
  >>> s = 'foobar'
>>> s [5: 0: -2]
'rbo'
  

В приведенном выше примере 5: 0: -2 означает «начать с последнего символа и сделать шаг назад на 2 , вплоть до первого символа, но не включая его».

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

>>>
  >>> s = '12345' * 5
>>> с
'1234512345123451234512345'
>>> s [:: - 5]
'55555'
  

Это обычная парадигма переворачивания строки:

>>>
  >>> s = 'Если товарищ Наполеон так говорит, значит, это правильно'.
>>> s [:: - 1]
'.thgir eb tsum ti, ti syas noelopaN edarmoC fI'
  

Интерполяция переменных в строку

В версии Python 3.6 был представлен новый механизм форматирования строк.Эта функция официально называется литералом форматированной строки, но чаще упоминается по псевдониму f-string .

Возможности форматирования, предоставляемые f-строками, обширны и не будут здесь подробно рассматриваться. Если вы хотите узнать больше, вы можете ознакомиться со статьей Real Python «f-строки Python 3: улучшенный синтаксис форматирования строк» ​​(руководство). Позже в этой серии вы найдете учебное пособие по форматированному выводу, в котором более подробно рассматриваются f-строки.

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

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

>>>
  >>> п = 20
>>> m = 25
>>> prod = n * m
>>> print ('Произведение', n, 'и', m, 'is', prod)
Произведение 20 и 25 равно 500.
  

Но это громоздко.Чтобы сделать то же самое, используя f-строку:

  • Укажите строчные буквы f или прописные F непосредственно перед открывающей кавычкой строкового литерала. Это говорит Python, что это f-строка, а не стандартная строка.
  • Укажите любые переменные для интерполяции в фигурных скобках ( {} ).

Переделайте с использованием f-строки, приведенный выше пример выглядит намного чище:

>>>
  >>> п = 20
>>> m = 25
>>> prod = n * m
>>> print (f'Произведение {n} и {m} равно {prod} ')
Произведение 20 и 25 равно 500.
  

Для определения f-строки можно использовать любой из трех механизмов цитирования Python:

>>>
  >>> var = 'Кора'

>>> print (f'A dog говорит {var}! ')
Собака говорит: "Лай!"
>>> print (f "Собака говорит {var}!")
Собака говорит: "Лай!"
>>> print (f '' 'Собака говорит {var}!' '')
Собака говорит: "Лай!"
  

Изменение строк

Короче говоря, нельзя.Строки - это один из типов данных, которые Python считает неизменяемыми, то есть не подлежащими изменению. Фактически, все типы данных, которые вы видели до сих пор, неизменяемы. (Как вы скоро увидите, Python предоставляет типы данных, которые являются изменяемыми.)

Подобная инструкция вызовет ошибку:

>>>
  >>> s = 'foobar'
>>> s [3] = 'х'
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    s [3] = 'x'
TypeError: объект 'str' не поддерживает назначение элементов
  

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

>>>
  >>> s = s [: 3] + 'x' + s [4:]
>>> с
'fooxar'
  

Для этого существует также встроенный строковый метод:

>>>
  >>> s = 'foobar'
>>> s = s.replace ('б', 'х')
>>> с
'fooxar'
  

Прочтите, чтобы узнать больше о встроенных строковых методах!

Встроенные строковые методы

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

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

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

Синтаксис вызова метода для объекта следующий:

Это вызывает метод .foo () для объекта obj . указывает аргументы, передаваемые методу (если есть).

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

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

Преобразование корпуса

Методы этой группы выполняют преобразование регистра в целевой строке.

s.capitalize ()

Делает целевую строку заглавной.

s.capitalize () возвращает копию s с первым символом, преобразованным в верхний регистр, а все остальные символы преобразованы в нижний регистр:

>>>
  >>> s = 'foO BaR BAZ quX'
>>> s.capitalize ()
'Foo bar baz qux'
  

Неалфавитные символы без изменений:

>>>
  >>> s = 'foo123 # BAR #.'
>>> s.capitalize ()
'Foo123 # bar #.'
  

с. Нижний ()

Преобразует буквенные символы в нижний регистр.

s.lower () возвращает копию s со всеми буквенными символами, преобразованными в нижний регистр:

>>>
  >>> 'FOO Bar 123 baz qUX'.lower ()
'foo bar 123 baz qux'
  

s.swapcase ()

Меняет местами регистр буквенных символов.

с.swapcase () возвращает копию s с прописными буквенными символами, преобразованными в строчные и наоборот:

>>>
  >>> 'FOO Bar 123 baz qUX'.swapcase ()
'foo bAR 123 BAZ Qux'
  

наименование ()

Преобразует целевую строку в «регистр заголовка».

s.title () возвращает копию s , в которой первая буква каждого слова преобразована в верхний регистр, а остальные буквы в нижний регистр:

>>>
  >>> 'солнце тоже встает'.заглавие()
"И солнце восходит"
  

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

>>>
  >>> «что случилось с акциями IBM Теда?». Title ()
"Что случилось с Ibm Stock Теда?"
  

с. Верх. ()

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

с.upper () возвращает копию s со всеми буквенными символами, преобразованными в верхний регистр:

>>>
  >>> 'FOO Bar 123 baz qUX'.upper ()
'FOO BAR 123 BAZ QUX'
  
Найти и заменить

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

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

s.count ( [, [, ]])

Подсчитывает количество вхождений подстроки в целевой строке.

s.count () возвращает количество неперекрывающихся вхождений подстроки за с :

>>>
  >>> 'foo goo moo'.count ('oo')
3
  

Счетчик ограничен количеством вхождений в подстроке, указанной как <начало> и <конец> , если они указаны:

>>>
  >>> 'foo goo moo'.count (' oo ', 0, 8)
2
  

s.endswith (<суффикс> [, <начало> [, <конец>]])

Определяет, заканчивается ли целевая строка заданной подстрокой.

s.endswith (<суффикс>) возвращает True , если s заканчивается указанным <суффикс> и False в противном случае:

>>>
  >>> 'foobar'.заканчивается ('бар')
Правда
>>> 'foobar'.endswith (' баз ')
Ложь
  

Сравнение ограничено подстрокой, указанной как и , если они указаны:

>>>
  >>> 'foobar'.endswith (' oob ', 0, 4)
Правда
>>> 'foobar'.endswith (' oob ', 2, 4)
Ложь
  

s.find ( [, [, ]])

Ищет в целевой строке заданную подстроку.

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

>>>
  >>> 'foo bar foo baz foo qux'.find (' foo ')
0
  

Этот метод возвращает -1 , если указанная подстрока не найдена:

>>>
  >>> 'foo bar foo baz foo qux'.найти ('grault')
-1
  

Поиск ограничен подстрокой, указанной как и , если они указаны:

>>>
  >>> 'foo bar foo baz foo qux'.find (' foo ', 4)
8
>>> 'фу бар фу баз фу qux'.find (' фу ', 4, 7)
-1
  

s.index ( [, [, ]])

Ищет в целевой строке заданную подстроку.

Этот метод идентичен .find () , за исключением того, что он вызывает исключение, если не найден, а не возвращает -1 :

>>>
  >>> 'foo bar foo baz foo qux'.index (' grault ')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    'foo bar foo baz foo qux'.index (' grault ')
ValueError: подстрока не найдена
  

s.rfind ( [, [, ]])

Ищет в целевой строке заданную подстроку, начиная с конца.

s.rfind () возвращает наивысший индекс за s , где найдена подстрока :

>>>
  >>> 'foo bar foo baz foo qux'.rfind (' foo ')
16
  

Как и в случае с .find () , если подстрока не найдена, возвращается -1 :

>>>
  >>> 'foo bar foo baz foo qux'.rfind (' grault ')
-1
  

Поиск ограничен подстрокой, указанной как и , если они указаны:

>>>
  >>> 'foo bar foo baz foo qux'.rfind ('фу', 0, 14)
8
>>> 'фу бар фу баз фу qux'.rfind (' фу ', 10, 14)
-1
  

s.rindex ( [, [, ]])

Ищет в целевой строке заданную подстроку, начиная с конца.

Этот метод идентичен .rfind () , за исключением того, что он вызывает исключение, если не найден, а не возвращает -1 :

>>>
  >>> 'foo bar foo baz foo qux'.rindex ('граулт')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    'foo bar foo baz foo qux'.rindex (' граулт ')
ValueError: подстрока не найдена
  

s.startswith (<префикс> [, [, ]])

Определяет, начинается ли целевая строка с данной подстроки.

Когда вы используете метод Python .startswith () , s.startswith () возвращает True , если s начинается с указанного и False в противном случае:

>>>
  >>> 'foobar'.начинается с ('фу')
Правда
>>> 'foobar'.startswith (' бар ')
Ложь
  

Сравнение ограничено подстрокой, указанной как и , если они указаны:

>>>
  >>> 'foobar'.startswith (' bar ', 3)
Правда
>>> 'foobar'.startswith (' бар ', 3, 2)
Ложь
  
Классификация персонажей

Методы этой группы классифицируют строку на основе содержащихся в ней символов.

s.isalnum ()

Определяет, состоит ли целевая строка из буквенно-цифровых символов.

s.isalnum () возвращает True , если s непусто и все его символы являются буквенно-цифровыми (буква или число), а False в противном случае:

>>>
  >>> 'abc123'.isalnum ()
Правда
>>> 'abc $ 123'.isalnum ()
Ложь
>>> '' .isalnum ()
Ложь
  

с.isalpha ()

Определяет, состоит ли целевая строка из буквенных символов.

s.isalpha () возвращает True , если s непусто и все его символы буквенные, и False в противном случае:

>>>
  >>> 'ABCabc'.isalpha ()
Правда
>>> 'abc123'.isalpha ()
Ложь
  

s.isdigit ()

Определяет, состоит ли целевая строка из цифровых символов.

Вы можете использовать метод Python .isdigit () , чтобы проверить, состоит ли ваша строка только из цифр. s.isdigit () возвращает True , если s непусто и все его символы являются числовыми цифрами, и False в противном случае:

>>>
  >>> '123'.isdigit ()
Правда
>>> '123abc'.isdigit ()
Ложь
  

s.isidentifier ()

Определяет, является ли целевая строка допустимым идентификатором Python.

s.isidentifier () возвращает True , если s является допустимым идентификатором Python в соответствии с определением языка, и False в противном случае:

>>>
  >>> 'foo32'.isidentifier ()
Правда
>>> '32foo'.isidentifier ()
Ложь
>>> 'foo $ 32'.isidentifier ()
Ложь
  

Примечание: .isidentifier () вернет True для строки, которая соответствует ключевому слову Python, даже если на самом деле это не будет действительным идентификатором:

>>>
  >>> 'и'.isidentifier ()
Правда
  

Вы можете проверить, соответствует ли строка ключевому слову Python, используя функцию iskeyword () , которая содержится в модуле keyword . Один из возможных способов сделать это показан ниже:

>>>
  >>> from keyword import iskeyword
>>> iskeyword ('и')
Правда
  

Если вы действительно хотите убедиться, что строка будет служить допустимым идентификатором Python, вам следует проверить, что .isidentifier () - это True , а iskeyword () - это False .

См. Модули и пакеты Python - Введение, чтобы узнать больше о модулях Python.

с. Ниже ()

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

s.islower () возвращает True , если s непусто и все содержащиеся в нем буквенные символы строчные, а False в противном случае.Неалфавитные символы игнорируются:

>>>
  >>> 'abc'.islower ()
Правда
>>> 'abc1 $ d'.islower ()
Правда
>>> 'Abc1 $ D'.islower ()
Ложь
  

s. Печатная ()

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

s.isprintable () возвращает True , если s пусто или все содержащиеся в нем буквенные символы можно распечатать.Он возвращает False , если s содержит хотя бы один непечатаемый символ. Неалфавитные символы игнорируются:

>>>
  >>> 'a \ tb'.isprintable ()
Ложь
>>> 'a b'.isprintable ()
Правда
>>> '' .isprintable ()
Правда
>>> 'a \ nb'.isprintable ()
Ложь
  

Примечание: Это единственный метод .isxxxx () , который возвращает True , если s - пустая строка. Все остальные возвращают False для пустой строки.

s. Пробел ()

Определяет, состоит ли целевая строка из символов пробела.

s.isspace () возвращает True , если s непусто и все символы являются пробельными символами, и False в противном случае.

Наиболее часто встречающиеся пробельные символы - это пробел '' , табуляция '\ t' и новая строка '\ n' :

>>>
  >>> '\ t \ n'.isspace ()
Правда
>>> 'а' .isspace ()
Ложь
  

Однако есть несколько других символов ASCII, которые квалифицируются как пробелы, и если вы учитываете символы Unicode, их довольно много помимо этого:

>>>
  >>> '\ f \ u2005 \ r'.isspace ()
Правда
  

( '\ f' и '\ r' - это escape-последовательности для символов подачи формы ASCII и символов возврата каретки; '\ u2005' - это escape-последовательность для Unicode Four-Per-Em Space.)

с. Название ()

Определяет, имеет ли целевая строка регистр заголовка.

s.istitle () возвращает True , если s непусто, первый буквенный символ каждого слова - заглавные, а все остальные алфавитные символы в каждом слове - строчные. Он возвращает False иначе:

>>>
  >>> 'This Is A Title'.istitle ()
Правда
>>> 'Это заголовок'.istitle ()
Ложь
>>> «Дайте мне # $ # @ Ball!».istitle ()
Правда
  

Примечание: Вот как в документации Python описывается .istitle () , на случай, если вы сочтете это более интуитивным: «Символы верхнего регистра могут следовать только за символами без регистра, а за символами в нижнем регистре - только за ними».

с. Верхний ()

Определяет, являются ли буквенные символы целевой строки прописными.

s.isupper () возвращает True , если s непусто и все содержащиеся в нем буквенные символы прописные, а False в противном случае.Неалфавитные символы игнорируются:

>>>
  >>> 'ABC'.isupper ()
Правда
>>> 'ABC1 $ D'.isupper ()
Правда
>>> 'Abc1 $ D'.isupper ()
Ложь
  
Форматирование строки

Методы этой группы изменяют или улучшают формат строки.

s.center ( [, ])

Центрирует строку в поле.

s.center () возвращает строку, состоящую из s с центром в поле шириной .По умолчанию заполнение состоит из символа пробела ASCII:

. >>>
  >>> 'foo'.center (10)
'фу'
  

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

>>>
  >>> 'bar'.center (10,' - ')
'---бар----'
  

Если с уже не меньше <ширина> , он возвращается без изменений:

>>>
  >>> 'foo'.центр (2)
'фу'
  

s.expandtabs (tabsize = 8)

Расширяет табуляции в строку.

s.expandtabs () заменяет каждый символ табуляции ( '\ t' ) пробелами. По умолчанию пробелы заполняются с учетом позиции табуляции в каждом восьмом столбце:

>>>
  >>> 'a \ tb \ tc'.expandtabs ()
'а б в'
>>> 'aaa \ tbbb \ tc'.expandtabs ()
'aaa bbb c'
  

tabsize - необязательный параметр ключевого слова, определяющий альтернативные столбцы табуляции:

>>>
  >>> 'а \ tb \ tc'.expandtabs (4)
'а б в'
>>> 'aaa \ tbbb \ tc'.expandtabs (tabsize = 4)
'aaa bbb c'
  

s.ljust (<ширина> [, <заполнить>])

Выравнивает строку в поле по левому краю.

s.ljust () возвращает строку, состоящую из s , выровненных по левому краю, в поле шириной . По умолчанию заполнение состоит из символа пробела ASCII:

. >>>
  >>> 'foo'.ljust (10)
'фу'
  

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

>>>
  >>> 'foo'.ljust (10, '-')
'фу -------'
  

Если с уже не меньше <ширина> , он возвращается без изменений:

>>>
  >>> 'foo'.ljust (2)
'фу'
  

s.lstrip ([])

Обрезает начальные символы строки.

s.lstrip () возвращает копию s с любыми пробельными символами, удаленными с левого края:

>>>
  >>> 'foo bar baz'.lstrip ()
'foo bar baz'
>>> '\ t \ nfoo \ t \ nbar \ t \ nbaz'.lstrip ()
'foo \ t \ nbar \ t \ nbaz'
  

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

>>>
  >>> 'http: //www.realpython.com'.lstrip (' /: pth ')
"www.realpython.com"
  

s.replace (, [, ])

Заменяет вхождения подстроки в строке.

В Python для удаления символа из строки можно использовать метод Python string .replace () . s.replace (, ) возвращает копию s со всеми вхождениями подстроки , замененной на :

>>>
  >>> 'foo bar foo baz foo qux'.replace (' foo ',' grault ')
'Grault Bar Grault Baz Grault Qux'
  

Если указан необязательный аргумент , выполняется максимум замен, начиная с левого конца s :

>>>
  >>> 'foo bar foo baz foo qux'.replace ('фу', 'граулт', 2)
'grault bar grault baz foo qux'
  

s.rjust (<ширина> [, <заполнить>])

Выравнивает строку в поле по правому краю.

s.rjust () возвращает строку, состоящую из s , выровненных по правому краю, в поле шириной . По умолчанию заполнение состоит из символа пробела ASCII:

. >>>
  >>> 'foo'.rjust (10)
'фу'
  

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

>>>
  >>> 'foo'.rjust (10, '-')
'------- фу'
  

Если с уже не меньше <ширина> , он возвращается без изменений:

>>>
  >>> 'foo'.rjust (2)
'фу'
  

s.rstrip ([])

Обрезает завершающие символы строки.

s.rstrip () возвращает копию s с удаленными пробельными символами с правого конца:

>>>
  >>> 'foo bar baz'.rstrip ()
'foo bar baz'
>>> 'foo \ t \ nbar \ t \ nbaz \ t \ n'.rstrip ()
'foo \ t \ nbar \ t \ nbaz'
  

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

>>>
  >>> 'foo. $$$;'. Rstrip ('; $.')
'фу'
  

s.strip ([])

Удаляет символы с левого и правого концов строки.

s.strip () по существу эквивалентен вызову s.lstrip () и s.rstrip () последовательно. Без аргумента он удаляет начальные и конечные пробелы:

>>>
  >>> s = 'foo bar baz \ t \ t \ t'
>>> s = s.lstrip ()
>>> s = s.rstrip ()
>>> с
'foo bar baz'
  

Как и в случае с .lstrip () и .rstrip () , необязательный аргумент определяет набор удаляемых символов:

>>>
  >>> 'www.realpython.com'.strip ('w.moc')
'realpython'
  

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

>>>
  >>> 'foo bar baz \ t \ t \ t'.lstrip (). Rstrip ()
'foo bar baz'
>>> 'foo bar baz \ t \ t \ t'.strip ()
'foo bar baz'

>>> 'www.realpython.com'.lstrip (' w.moc '). rstrip (' w.moc ')
'realpython'
>>> 'www.realpython.com'.полоса ('w.moc')
'realpython'
  

s.zfill (<ширина>)

Добавляет нули в строку слева.

s.zfill () возвращает копию s с заполнением слева '0' символов до указанного :

>>>
  >>> '42'.zfill (5)
«00042»
  

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

>>>
  >>> '+42'.zfill (8)
'+0000042'
>>> '-42'.zfill (8)
'-0000042'
  

Если с уже не меньше <ширина> , он возвращается без изменений:

>>>
  >>> '-42'.zfill (3)
'-42'
  

.zfill () наиболее полезен для строковых представлений чисел, но Python по-прежнему с радостью добавит нуля в строку, которая не равна:

>>>
  >>> 'foo'.zfill (6)
'000foo'
  
Преобразование между строками и списками

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

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

Многие из этих методов возвращают либо список, либо кортеж. Это два похожих составных типа данных, которые являются прототипами итераций в Python. Они будут рассмотрены в следующем руководстве, так что скоро вы узнаете о них! А пока считайте их просто последовательностями значений.Список заключен в квадратные скобки ( [] ), а кортеж заключен в круглые скобки ( () ).

После этого введения давайте взглянем на последнюю группу строковых методов.

s.join ()

Объединяет строки из итерируемого объекта.

s.join () возвращает строку, полученную в результате объединения объектов в , разделенных s .

Обратите внимание, что .join () вызывается на s , строке-разделителе. также должна быть последовательностью строковых объектов.

Некоторые примеры кода должны помочь прояснить ситуацию. В следующем примере разделитель s - это строка ',' , а - это список строковых значений:

>>>
  >>> ',' .join (['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'
  

Результат - одна строка, состоящая из объектов списка, разделенных запятыми.

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

>>>
  >>> список ('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'. join ('corge')
'c: o: r: g: e'
  

Таким образом, результатом ':'. Join ('corge') является строка, состоящая из каждого символа в 'corge' , разделенных ':' .

Этот пример не выполняется, потому что один из объектов в не является строкой:

>>>
  >>> '---'. Join (['foo', 23, 'bar'])
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    '---'. join (['foo', 23, 'bar'])
TypeError: элемент последовательности 1: ожидаемый экземпляр str, найдено int
  

Но это можно исправить:

>>>
  >>> '---'. Join (['foo', str (23), 'bar'])
'foo --- 23 --- bar'
  

Как вы вскоре увидите, многие составные объекты в Python могут быть сконструированы как итерируемые объекты, а .join () особенно полезен для создания из них строк.

раздел ()

Делит строку по разделителю.

s.partition () разбивает сек при первом появлении строки . Возвращаемое значение представляет собой кортеж, состоящий из трех частей:

  • Часть с , предшествующая
  • сам
  • Часть с после

Вот несколько примеров .partition () в действии:

>>>
  >>> 'foo.bar'.partition ('. ')
('фу', '.', 'бар')
>>> 'foo @@ bar @@ baz'.partition (' @@ ')
('foo', '@@', 'bar @@ baz')
  

Если не найден в s , возвращенный кортеж содержит s , за которыми следуют две пустые строки:

>>>
  >>> 'foo.bar'.partition (' @@ ')
('foo.bar', '', '')
  

Помните: Списки и кортежи рассматриваются в следующем руководстве.

с.р раздел ()

Делит строку по разделителю.

s.rpartition () работает точно так же, как s.partition () , за исключением того, что s.partition () разбивается на последнее вхождение вместо первого вхождения:

>>>
  >>> 'foo @@ bar @@ baz'.partition (' @@ ')
('foo', '@@', 'bar @@ baz')

>>> 'foo @@ bar @@ baz'.rpartition (' @@ ')
('foo @@ bar', '@@', 'baz')
  

с.rsplit (sep = Нет, maxsplit = -1)

Разбивает строку на список подстрок.

Без аргументов s.rsplit () разбивает s на подстроки, разделенные любой последовательностью пробелов, и возвращает подстроки в виде списка:

>>>
  >>> 'foo bar baz qux'.rsplit ()
['foo', 'bar', 'baz', 'qux']
>>> 'foo \ n \ tbar baz \ r \ fqux'.rsplit ()
['foo', 'bar', 'baz', 'qux']
  

Если указано , оно используется как разделитель для разделения:

>>>
  >>> 'foo.bar.baz.qux'.rsplit (sep = '.')
['foo', 'bar', 'baz', 'qux']
  

(Если указано со значением None , строка разделяется пробелами, как если бы не было указано вообще.)

Когда явно задано как разделитель, предполагается, что последовательные разделители в s ограничивают пустые строки, которые будут возвращены:

>>>
  >>> 'foo...bar'.rsplit (sep = '.')
['фу', '', '', 'бар']
  

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

>>>
  >>> 'foo \ t \ t \ tbar'.rsplit ()
['фу', 'бар']
  

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

>>>
  >>> 'www.realpython.com'.rsplit (sep = '.', maxsplit = 1)
['www.realpython', 'com']
  

Значение по умолчанию для составляет -1 , что означает, что должны быть выполнены все возможные разбиения - так же, как если бы полностью опущено:

>>>
  >>> 'www.realpython.com'.rsplit (sep ='. ', Maxsplit = -1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit (sep ='. ')
['www', 'realpython', 'com']
  

с.split (sep = None, maxsplit = -1)

Разбивает строку на список подстрок.

s.split () ведет себя точно так же, как s.rsplit () , за исключением того, что если указано , разделения отсчитываются с левого конца с , а не с правого конца:

>>>
  >>> 'www.realpython.com'.split ('. ', Maxsplit = 1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit ('. ', maxsplit = 1)
['www.realpython ',' com ']
  

Если не указано, .split () и .rsplit () неотличимы.

s.splitlines ([])

Разрывает строку по границам строки.

s.splitlines () разбивает s на строки и возвращает их в виде списка. Любой из следующих символов или последовательностей символов считается границей строки:

Последовательность побега Персонаж
\ n Новая строка
\ r Возврат каретки
\ r \ n Возврат каретки + перевод строки
\ v или \ x0b Строчная таблица
\ f или \ x0c Подача формы
\ x1c Разделитель файлов
\ x1d Разделитель групп
\ x1e Разделитель записей
\ x85 Следующая строка (контрольный код C1)
\ u2028 Разделитель строк Unicode
\ u2029 Разделитель абзацев Unicode

Вот пример использования нескольких разных разделителей строк:

>>>
  >>> 'foo \ nbar \ r \ nbaz \ fqux \ u2028quux'.splitlines ()
['foo', 'bar', 'baz', 'qux', 'quux']
  

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

>>>
  >>> 'foo \ f \ f \ fbar'.splitlines ()
['фу', '', '', 'бар']
  

Если необязательный аргумент указан и является истинным, то границы строк сохраняются в строках результатов:

>>>
  >>> 'foo \ nbar \ nbaz \ nqux'.splitlines (True)
['foo \ n', 'bar \ n', 'baz \ n', 'qux']
>>> 'foo \ nbar \ nbaz \ nqux'.splitlines (1)
['foo \ n', 'bar \ n', 'baz \ n', 'qux']
  

Строковые методы Python: пошаговое руководство

Python имеет много методов, используемых исключительно для строк. Строковые методы Python включают upper () , lower () , capitalize () , title () и другие. Эти строковые методы полезны для манипулирования, редактирования и работы со строками.

Найди свой учебный лагерь