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

Содержание

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

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

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

Ниже рассмотрим операторы, методы и функции, доступные для работы с текстом.

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

Вы уже видели операторы + и * в применении их к числовым значениям в уроке по операторам в Python . Эти два оператора применяются и к строкам.

Оператор сложения строк +

+ — оператор конкатенации строк. Он возвращает строку, состоящую из других строк, как показано здесь:

>>> s = 'py'
>>> t = 'th'
>>> u = 'on'

>>> s + t
'pyth'
>>> s + t + u
'python'

>>> print('Привет, ' + 'Мир!')
Go team!!!

Оператор умножения строк *

* — оператор создает несколько копий строки. Если s это строка, а n целое число, любое из следующих выражений возвращает строку, состоящую из n объединенных копий s:

s * n
n * s

Вот примеры умножения строк:

>>> s = 'py.'

>>> s * 4
'py.py.py.py.'
>>> 4 * s
'py.py.py.py.'

Значение множителя n должно быть целым положительным числом. Оно может быть нулем или отрицательным, но этом случае результатом будет пустая строка:

>>> 'py' * -6
''

Если вы создадите строковую переменную и превратите ее в пустую строку, с помощью 'py' * -6, кто-нибудь будет справедливо считать вас немного глупым. Но это сработает.

Оператор принадлежности подстроки in

Python также предоставляет оператор принадлежности, который можно использоваться для манипуляций со строками. Оператор in возвращает True, если подстрока входит в строку, и False, если нет:

>>> s = 'Python'
>>> s in 'I love Python.'
True
>>> s in 'I love Java.'
False

Есть также оператор

not in, у которого обратная логика:

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

Встроенные функции строк в python

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

Функция Описание
chr() Преобразует целое число в символ
ord() Преобразует символ в целое число
len() Возвращает длину строки
str() Изменяет тип объекта на string

Более подробно о них ниже.

Функция ord(c) возвращает числовое значение для заданного символа.

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

Самая простая схема в повседневном использовании называется ASCII . Она охватывает латинские символы, с которыми мы чаще работает. Для этих символов ord(c) возвращает значение ASCII для символа c:

>>> ord('a')
97
>>> ord('#')
35

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

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

Python 3 поддерживает Unicode, в том числе позволяет использовать символы Unicode в строках.

Функция ord() также возвращает числовые значения для символов Юникода:

>>> ord('€')
8364
>>> ord('∑')
8721

Функция chr(n) возвращает символьное значение для данного целого числа.

chr() действует обратно ord(). Если задано числовое значение n, chr(n) возвращает строку, представляющую символ n:

>>> chr(97)
'a'
>>> chr(35)
'#'

chr() также обрабатывает символы Юникода:

>>> chr(8364)
'€'
>>> chr(8721)
'∑'

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

len(s) возвращает количество символов в строке s:

>>> s = 'Простоя строка. '
>>> len(s)
15

Функция str(obj) возвращает строковое представление объекта.

Практически любой объект в Python может быть представлен как строка. str(obj) возвращает строковое представление объекта obj:

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('py')
'py'

Индексация строк

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

В Python строки являются упорядоченными последовательностями символьных данных и могут быть проиндексированы. Доступ к отдельным символам в строке можно получить, указав имя строки, за которым следует число в квадратных скобках [].

Индексация строк начинается с нуля: у первого символа индекс 0, следующего 1 и так далее. Индекс последнего символа в python — ‘‘длина строки минус один’’.

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

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

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> s[5]
'r'

Попытка обращения по индексу большему чем len(s) - 1, приводит к ошибке IndexError:

>>> s[6]
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    s[6]
IndexError: string index out of range

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

Вот несколько примеров отрицательного индексирования:

>>> s = 'foobar'
>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)] 
'f'

Попытка обращения по индексу меньшему чем -len(s), приводит к ошибке IndexError:

>>> s[-7]
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    s[-7]
IndexError: string index out of range

Для любой непустой строки s, код s[len(s)-1] и s[-1] возвращают последний символ. Нет индекса, который применим к пустой строке.

Срезы строк

Python также допускает возможность извлечения подстроки из строки, известную как ‘‘string slice’’. Если

s это строка, выражение формы s[m:n] возвращает часть s, начинающуюся с позиции m, и до позиции n, но не включая позицию:

>>> s = 'python'
>>> s[2:5]
'tho'

Помните: индексы строк в python начинаются с нуля. Первый символ в строке имеет индекс 0. Это относится и к срезу.

Опять же, второй инде

Приемы работы со строками в Python.

Использование текстовых строк str в Python.

Язык программирования Python может манипулировать строками, которые могут быть записаны несколькими способами. Текстовые строки могут быть заключены в одинарные кавычки ('...') или двойные кавычки ("..."), что в результате будет одно и то же.

Знак обратной косой черты '\' может использоваться для экранирования кавычек:

# одинарные кавычки
>>> 'spam eggs' 
# 'spam eggs'

# используем \' для экранирования кавычки
>>> 'doesn\'t'
# "doesn't"

# или вместо этого, используйте двойные кавычки
>>> "doesn't"
"doesn't"

>>> '"Yes," they said.'
# '"Yes," they said.'
>>> "\"Yes,\" they said."
# '"Yes," they said.'
>>> '"Isn\'t," they said.'
# '"Isn\'t," they said.'

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

>>> '"Isn\'t," they said.'
# '"Isn\'t," they said.'

>>> print('"Isn\'t," they said.')
# "Isn't," they said.

# \n означает новую строку
>>> s = 'First line.\nSecond line.
' # без print(), \n включается в вывод >>> s # 'First line.\nSecond line.' # с помощью print(), \n создает новую строку >>> print(s) # First line. # Second line.

Если вы не хотите, чтобы символы перед обратной косой чертой '\' интерпретировались как специальные символы, вы можете использовать необработанные (сырые) строки, добавив 'r' перед первой кавычкой:

# здесь \n создаст новую строку
>>> print('C:\some\name')
# C:\some
# ame

# обратите внимание на букву 'r' перед кавычкой
>>> print(r'C:\some\name')
# C:\some\name

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

или '''...'''. Конец строк автоматически включается в строку, но это можно предотвратить, добавив \в конец строки. Следующий пример:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

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

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

Строки могут быть объединены (склеены) оператором '+' и повторены с помощью '*':

# 3 раза "un", затем "ium"
>>> 3 * 'un' + 'ium'
# 'unununium'

Два или более строковых литерала, те, которые заключены в кавычки рядом друг с другом, автоматически объединяются. # SyntaxError: invalid syntax

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

>>> prefix + 'thon'
# 'Python'

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

>>> word = 'Python'
>>> word[0]
# 'P'

# символ в позиции 5
>>> word[5]
# 'n'

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

# последний символ
>>> word[-1]
# 'n'

# предпоследний символ
>>> word[-2]
# 'o'
>>> word[-6]
# 'P'

Обратите внимание, что, поскольку -0 совпадает с 0, отрицательные индексы начинаются с -1.

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

# символы от позиции 0 (включен) до позиции 2 (исключен)
>>> word[0:2]
# 'Py'

# символы от позиции 2 (включен) до позиции 5 (исключен)
>>> word[2:5]
# 'tho'

Обратите внимание, что начало среза всегда включено, а конец среза всегда исключен. Это гарантирует, что str[:i] + str[i:] всегда равно str:

>>> word[:2] + word[2:]
# 'Python'
>>> word[:4] + word[4:]
# 'Python'

Индексы срезов имеют полезные значения по умолчанию. Пропущенный первый индекс по умолчанию равен нулю, пропущенный второй индекс по умолчанию равен размеру/длине разрезаемой строки.

# символы от начала до позиции 2, который исключен
>>> word[:2]
# 'Py'

# символы от позиции 4 - включен, до конца строки
>>> word[4:]
# 'on'

# символы от предпоследнего (включенного) до конца
>>> word[-2:]
# 'on'

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

+---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

Первая строка чисел дает положение индексов 0… 6, второй ряд дает соответствующие отрицательные показатели. Срез от i до j состоит из всех символов между ребрами, обозначенными i и j соответственно.

Для неотрицательных индексов длина среза является разностью индексов, если оба находятся в пределах границ. Например, длина word[1:3] составляет 2.

Попытка использовать индекс, который больше длины строки приведет к ошибке:

# в слове всего 6 символов
>>> word[42]
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# IndexError: string index out of range

Однако индексы срезов вне диапазона обрабатываются изящно и не дают ошибок:

>>> word[4:42]
# 'on'
>>> word[42:]
# ''

Строки Python не могут быть изменены — они неизменны. Следовательно, присвоение элемента по индексу позиции в строке приводит к ошибке:

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

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

Если вам нужна другая строка, вы должны создать новую:

>>> 'J' + word[1:]
# 'Jython'

>>> word[:2] + 'py'
# 'Pypy'

Если вам нужно заменить несколько символов в исходной строке, используйте метод str. replace(). При этом будет все равно создана новая строка, а исходная останется неизменной:

>>> word.replace('P', 'J').replace('thon', 'py')
# 'Pypy'

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

>>> s = 'Строковые Методы'
>>> len(s)
# 16

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

Операции с текстовыми строками str в Python.

Методы и функции строк str.

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

Строки — тип str используются почти в каждой программе на Python. Поэтому уделите чуть больше внимание представленным здесь методам текстовых строк.

Напоминаем: Для строк еще доступны все общие операции c последовательностями;


Метод str.casefold() в Python, сворачивает регистр строки.

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

Метод str.format() в Python, форматирует строку.

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

Метод str.format_map() в Python.

Метод `str.format_map()` работает аналогично `str.format(**mapping)`, за исключением того, что `mapping` используется напрямую и не копируется в словарь `dict`. Это полезно, если, например `mapping`, подкласс `dict`.

Метод str.ljust() в Python, ровняет строку по левому краю.

Метод str.ljust() вернет новую строку с текстом str, выровненным по левому краю и шириной width. Заполнение строки str выполняется с использованием указанного символа fillchar. По умолчанию используется пробел ASCII.

Метод str.maketrans() в Python.

Статический метод str.maketrans() таблицу преобразования символов, используемую для метода str.translate().

Метод str.rsplit() в Python, делит строку с права.

Метод str.rsplit() возвращает список подстрок (слов) из строки str, используя разделитель sep в качестве разделителя строки str. Метод str.rsplit() деление строки начинает с права.

Метод str.split() в Python, делит строку по подстроке.

Метод str.split() возвращает список слов в строке, используя sep в качестве разделителя строки. Если задан maxsplit, то выполняется не более maxsplit разбиений, таким образом, список будет иметь не более maxsplit+1 элементов.

Метод str.splitlines() в Python, делит текст по символу ‘\n’.

Метод str.splitlines() возвращает список строк, текста str, разделенного по универсальным разрывам строк. Разрывы (разделители) строк не включаются в результирующий список, если не задано значение keepends=True.

Метод str. strip() в Python, обрежет строку с обоих концов.

Метод str.strip() вернет копию строки str с удаленными начальными и конечными символами chars. Другими словами, обрежет строку str с обоих концов. Аргумент chars — это строка, указывающая набор удаляемых символов.

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

«F-строки» обеспечивают краткий, читаемый способ включения значения выражений Python внутри строк. В исходном коде Python форматированная строка или по другому f-string — это буквальная строка с префиксом 'f' или 'F', которая содержит выражения внутри фигурных скобок {}. Выражения заменяются их значениями.

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

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

Выражения в форматированных строках рассматриваются как обычные выражения Python, окруженные круглыми скобками, за некоторыми исключениями:

  • Пустое выражение недопустимо.
  • Как лямбда-выражения, так и выражения присваивания := должны быть заключены в явные круглые скобки.
  • Выражения замены могут содержать разрывы строк, например в строках с тройными кавычками, но они не могут содержать комментарии.
  • Каждое выражение вычисляется в контексте, где отображается форматированный строковый литерал, в порядке слева направо.

Если указаны преобразования (!o или !a или !r) , то перед форматированием вычисляется результат преобразования. Затем результат форматируется с помощью протокола str.format(). Спецификатор формата передается в метод __format__() выражения или результата преобразования. Отформатированный результат затем включается в конечное значение всей строки.

Спецификация формата Mini-Language совпадает с языком, используемым во встроенной функции format().

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

Спецификатор '=' в f-строках:

Для самостоятельного документирования выражений и отладки в Python-3.8.1 добавлен спецификатор '=' к f-строкам. F-строка, такая как f'{expr=}', расширится до текста выражения и знака равенства, а затем представления вычисляемого выражения. Например:

>>> user = 'eric_idle'
>>> member_since = date(1975, 7, 31)
>>> f'{user=} {member_since=}'
# "user='eric_idle' member_since=datetime.date(1975, 7, 31)"

Обычные спецификаторы формата f-string позволяют более точно контролировать способ отображения результата выражения:

>>> delta = date. today() - member_since
>>> f'{user=!s}  {delta.days=:,d}'
# 'user=eric_idle  delta.days=16,075'

Спецификатор = будет отображать все выражение, чтобы можно было показать вычисления:

>>> print(f'{theta=}  {cos(radians(theta))=:.3f}')
theta=30  cos(radians(theta))=0.866

Примеры:

>>> name = 'Fred'
>>> f'He said his name is {name!r}.'
# 'He said his name is 'Fred'.'

# repr() является эквивалентом '!r'
>>> f`He said his name is {repr(name)}.`
# `He said his name is 'Fred'.`

# Вложенные поля
>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f`result: {value:{width}.{precision}}`
'result:      12.35'

# Использование спецификатора формата даты
>>> today = datetime(year=2017, month=1, day=27)
>>> f`{today:%B %d, %Y}`
'January 27, 2017'

# Использование спецификатора целочисленного формата
>>> number = 1024
>>> f"{number:#0x}"
'0x400'

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

>>> a = {'x': 120}
>>> f'abc {a['x']} def'
#   File "<stdin>", line 1
#     f'abc {a['x']} def'
#               ^
# SyntaxError: invalid syntax

# Используйте различные кавычки
f"abc {a['x']} def"
# 'abc 120 def'

Обратные косые черты не допускаются в выражениях формата и вызовут ошибку:

>>> f'newline: {ord("\n")}'
#   File "<stdin>", line 1
# SyntaxError: f-string expression part cannot include a backslash

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

>>> newline = ord('\n')
>>> f'newline: {newline}'
# 'newline: 10'

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

>>> def foo():
...     f'Not a docstring'
...
>>> foo.__doc__ is None
True

Сравнение F-строк с методом str.format():

# метод str.format()
'{},waiters:{}'.format(extra, len(self._waiters))
# F-строка
f'{extra},waiters:{len(self._waiters)}'

# метод str.format()
message.append(" [line {0:2d}]".format(lineno))
# F-строка
message.append(f" [line {lineno:2d}]")

# метод str.format()
methoddef_name = "{}_METHODDEF".format(c_basename.upper())
# F-строка
methoddef_name = f"{c_basename.upper()}_METHODDEF"

# метод str.format()
print("Usage: {0} [{1}]".format(sys.argv[0], '|'.join('--'+opt for opt in valid_opts)), file=sys.stderr)
# F-строка
print(f"Usage: {sys.argv[0]} [{'|'.join('--'+opt for opt in valid_opts)}]", file=sys.stderr)

Python с нуля — часть 7: строки

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

Создать строку можно просто заключив символы в кавычки, при этом для Python одинарные кавычки (' ') имеют такое же значение, как и двойные (" ").

Создаётся строка простым присваивание значения переменной. Например:

var1 ='Hello World!'
var2 ="Python Programming"

Получение значений из строк

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

Например:

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

Результат выполнения этого кода:

var1[0]:  H
var2[1:5]:  ytho

Обновление данных в строках

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

var1 = 'Hello World!'

print "Updated String :- ", var1[:6] + 'Python'

Результат выполнения:

Updated String :-  Hello Python

Примечание: вообще, строки в Python являются неизменяемыми (immutable) объектами, и прямое присваивание нового значения элементу списка вызовет ошибку:

>>> string = 'String'; print string
String
>>> string[6] = 'G'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Но можно воспользоваться операцией конкатенации (см. ниже) для этого. При этом — сам объект в памяти остаётся прежним:

>>> string = 'String'; print id(string)
682907136
>>> string[:5] + 'G'; print id(string)
'StrinG'
682907136

Escape-последовательности

В таблице ниже приводится список символов, которые не отображаются на экране при обработке.

Они обрабатываются как в одинарных, так и в двойных кавычках.

Backslash
notation
Hexadecimal
character
Description
a 0x07 звуковой сигнал или предупреждение
b 0x08 возврат на одну позицию
cx control-x
C-x control-x
e 0x1b escape
f 0x0c команда принтера
M-C-x meta-Control-x
n 0x0a новая строка
nnn восьмеричное значение
r 0x0d возврат каретки
s 0x20 пробел
t 0x09 табуляция
v 0x0b вертикальная табуляция
x символ x
xnn шестнадцатеричное значение

Специальные строковые операторы

Предположим, переменная строки a содержит ‘Hello‘, а переменная b — ‘Python‘:

Operator Description Example
+ конкатенация — добавление значений с обеих сторон от оператора a + b вернёт HelloPython
* повторение — создаёт новую строку, в которой объединены копии той же строки a*2 вернёт HelloHello
[] срез (slice) — возвращает символ с указанным индексом a[1] вернёт e
[ : ] срез диапазона — возвращает символы с заданном диапазоне индексов a[1:4] вернёт ell
in членство (membership) — возвращает истину (true, 1) если заданный символ присутствует в строке H in a вернёт 1
not in членство  (membership) — возвращает истину (true, 1) если заданный символ не присутствует в строке M not in a вернёт 1
r/R обычная строка (raw string) — подавляет значение escape-последовательностей; синтаксис таких строк такой же, как  и у обычных строк, за исключением оператора r или R, который добавляется непосредтсвенно перед открывающей кавычкой print r’n’ вернёт  n и print R’n’ вернёт  n
% format — выполнение форматирования строки см. далее

Оператор форматирования строк

Одна из наиболее приятных возможностей в Python — оператор %. Этот оператор уникален для строковых типов данных и подобен функции printf() из языка С:

>>> print "My name is %s and weight is %d kg!" % ('Zara', 21)
My name is Zara and weight is 21 kg!

Другой, более наглядный и простой пример:

>>> print '%s is %s' % ('one', 'two')
one is two

В таблице представлен полный список символов, которые могут быть использованы с оператором %:

Format Symbol Conversion
%c один символ
%s преобразование строки данными другого str()-объекта
%i алиас %d
%d целое десятичное число
%u то же, что и %d (устарев?)
%o восьмеричное целое
%x шестнадцатеричное целое (строчные буквы)
%X шестнадцатеричное целое (ПРОПИСНЫЕ буквы)
%e экспоненциальное представление (строчная ‘e’)
%E экспоненциальное представление (прописная ‘e’)
%f вещественное число в десятичном виде
%g краткая версия для %f и %e
%G краткая версия для %f и %E

Кроме этого, есть дополнительные возможности:

Symbol Functionality
* argument specifies width or precision
left justification
+ display the sign
<sp> leave a blank space before a positive number
# add the octal leading zero ( ‘0’ ) or hexadecimal leading ‘0x’ or ‘0X’, depending on whether ‘x’ or ‘X’ were used.
0 pad from left with zeros (instead of spaces)
% ‘%%’ leaves you with a single literal ‘%’
(var) mapping variable (dictionary arguments)
m.n. m is the minimum total width and n is the number of digits to display after the decimal point (if appl.)

Тройные кавычки

Тройные кавычки в Python позволяют располагать текст в несколько строк и использовать в нём специальные символы, такие как табуляция (t), новая строка (n) и другие.

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

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

#!/usr/bin/python

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print para_str;

Результат выполнения этого кода:

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
 ], or just a NEWLINE within
the variable assignment will also show up.

Обратите внимание, что каждый специальный символ был превращен в его «печатную форму», а новые строки отображаются либо прямым переводом строки в тексте, либо escape-последовательностью (n).

«Сырые строки» (raw strings) не обрабатывают символ обратно слеша как специальный символ. Каждый символ, который указан в такой строке будет отображён «как есть»:

#!/usr/bin/python

print 'C:nowhere'

Результат выполнения этого кода:

C:nowhere

Теперь — давайте сделаем «необработанную строку» с помощью символа r перед открывающей кавычкой:

#!/usr/bin/python

print r'C:nowhere'

Результат выполнения:

C:nowhere

Строки с unicode

Обычные строки в Python записываются с помощью таблицы 8-ми битной ASCII символов, тогда как Unicode-строки хранятся в 16-ти битной таблице. Это позволяет использовать более разнообразные символы в ней, включая специальные символы различных языков.

Мы ограничимся такой Unicode-строкой:

#!/usr/bin/python

print u'Hello, world!'

Результат её выполнения:

Hello, world!

Как видно, Unicode-строки используют объявление с помощью символа u, так же как

Python | Операции со строками

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

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

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


name = "Tom"
surname = 'Smith'
print(name, surname)  # Tom Smith

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


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

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


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

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

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

print("Время пришло в гости отправится\nждет меня старинный друг")

На консоль выведет две строки:


Время пришло в гости отправится
ждет меня старинный друг

Тоже самое касается и последовательности \t, которая добавляет табляцию.

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

print("Кафе \"Central Perk\"")

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

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


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

Поэтому строка «1a» условно меньше, чем строка «aa». Вначале сравнение идет по первому символу. Если начальные символы обоих строк представляют цифры, то меньшей считается меньшая цифра, например, «1a» меньше, чем «2a».

Если начальные символы представляют алфавитные символы в одном и том же регистре, то смотрят по алфавиту. Так, «aa» меньше, чем «ba», а «ba» меньше, чем «ca».

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

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

Функция lower() приводит строку к нижнему регистру, а функция upper() — к верхнему.


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

print(str1.lower() == str2.lower())  # True

6.1. строка — Стандартные строковые операции — документация Python 3.5.10

Исходный код: Lib / string.py


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

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

строка. ascii_letters

Объединение ascii_lowercase и ascii_uppercase константы, описанные ниже. Это значение не зависит от языкового стандарта.

строка. ascii_lowercase

Строчные буквы 'abcdefghijklmnopqrstuvwxyz' . Это значение не зависит от локали и не изменится.

строка. ascii_uppercase

Заглавные буквы 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' . Это значение не зависит от локали и не изменится.

строка. цифр

Строка '0123456789' .

строка. шестнадцатеричные цифры

Строка '0123456789abcdefABCDEF' .

строка. восьмеричные цифры

Строка '01234567' .

строка. пунктуация

Строка символов ASCII, считающихся знаками пунктуации в локали C .

строка. для печати

Строка символов ASCII, которые считаются печатаемыми. Это комбинация цифр , ascii_letters , знаков препинания , и пробел .

строка. пустое пространство

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

6.1.2. Пользовательское форматирование строки

Встроенный строковый класс предоставляет возможность выполнять сложные переменные. подстановки и форматирование значений с помощью метода format () , описанного в ПЕР 3101 . Класс Formatter в модуле string позволяет вы можете создавать и настраивать свои собственные варианты форматирования строк, используя те же реализация как встроенная

Python String strip ()

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

Синтаксис метода strip () :

string.strip ([символы]) 

полоса () Параметры

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

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


Возвращаемое значение из метода strip ()

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


Обработка полосы () методом

  • Когда символ строки слева не совпадает со всеми символами в аргументе chars , он перестает удалять ведущие символы.
  • Аналогично, когда символ строки справа не совпадает со всеми символами в аргументе chars , он перестает удалять завершающие символы.

Пример: Работа метода strip ()

  строка = 'xoxo love xoxo'

# Начальные и конечные пробелы удаляются
печать (строка.полоса ())

# Все символы <пробел>, x, o, e слева
# и правая часть строки удаляются
печать (строка.стрип ('xoe'))

# Аргумент не содержит пробелов
# Никакие символы не удаляются.
печать (строка.стрип ('stx'))

строка = 'Android потрясающий'
print (string.strip ('an'))  

Выход

  xoxo любовь xoxo
любить
  xoxo любовь xoxo
дроид классный  

Здесь мы видим, что первое выражение string.strip () без каких-либо аргументов удалило пробелы слева и справа от string .

string.strip ('xoe') удалили все пробелы, x , o и e , ведущие или замыкающие строку.

Поскольку строка имеет пробелы в начале и в конце, выражение string.strip ('stx') не изменяет строку. x не удаляется, так как он находится в середине строки (пробелы ведут и следуют за строкой)

string.strip ('an') удалил и в начале строки.

Строка Python

— GeeksforGeeks

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

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

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

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

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

печать (String1)

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

печать ( "\ nСтрока с использованием двойных кавычек:" )

печать (String1)

Строка1 =

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

печать (String1)

Строка1 =

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

печать (String1)

Выход:

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

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

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

Создание многострочной строки:
Компьютерщики
            За
            Жизнь
 

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

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

String1 = "GeeksForGeeks"

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

печать (String1)

печать ( "\ nПервый символ строки:" )

печать (String1 [ 0 ])

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

печать (строка1 [ - 1 ])

Выход:


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

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

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

Нарезка струн

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

String1 = "GeeksForGeeks"

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

печать (String1)

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

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

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

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

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

Выход:

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

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

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

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

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

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

String1 = «Здравствуйте, я компьютерщик»

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

печать (String1)

Строка1 [ 2 ] = 'p'

печать ( "\ nОбновление символа во втором индексе:" )

печать (String1)

Ошибка:

Traceback (последний звонок последний):
Файл «/ home / 360bb1830c83a918fc78aa8979195653.py », строка 10, в
String1 [2] =‘ p ’
TypeError: объект‘ str ’не поддерживает присвоение элемента

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

String1 = «Здравствуйте, я компьютерщик»

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

печать (String1)

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

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

печать (String1)

Выход:

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

Лучшие практики форматирования строк Python — Real Python

Помните дзен Python и как должен быть «один очевидный способ сделать что-то на Python»? Вы можете почесать голову, когда узнаете, что существует , четыре основных способов форматирования строк в Python.

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

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

>>>
  >>> errno = 50159747054
>>> name = 'Боб'
  

На основе этих переменных вы хотите сгенерировать выходную строку, содержащую простое сообщение об ошибке:

>>>
  'Привет, Боб, произошла ошибка 0xbadc0ffee!'
  

Эта ошибка может действительно испортить утро понедельника разработчикам… Но мы здесь, чтобы обсудить форматирование строк.Итак, приступим к работе.

# 1 Форматирование строки «старого стиля» (оператор%)

Строки в Python имеют уникальную встроенную операцию, доступ к которой можно получить с помощью оператора % . Это позволяет очень легко выполнять простое позиционное форматирование. Если вы когда-нибудь работали с функцией в стиле printf на языке C, вы сразу поймете, как это работает. Вот простой пример:

>>>
  >>> 'Привет,% s'% name
"Привет, Боб"
  

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

Существуют и другие описатели формата, позволяющие управлять форматом вывода. Например, можно преобразовать числа в шестнадцатеричную систему счисления или добавить пробельные символы для создания красиво отформатированных таблиц и отчетов. (См. Документы Python: «Форматирование строк в стиле printf».)

Здесь вы можете использовать описатель формата % x для преобразования значения int в строку и представления его в виде шестнадцатеричного числа:

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

  • Дом
  • Тестирование

      • Назад
      • Гибкое тестирование
      • BugZilla
      • Огурец
      • Тестирование базы данных
      • Тестирование ETL
      • Jmeter
      • JIRA
      • Назад
      • JUnit
      • LoadRunner
      • Ручное тестирование
      • Мобильное тестирование
      • Богомол
      • Почтальон
      • QTP
      • Назад
      • Центр качества (ALM)
      • RPA

Учебное пособие по Python String — Строковые функции и операции Python

Бесплатный курс Python с 25 проектами (код купона: DATAFLAIR_PYTHON) Начать сейчас

1.Учебник Python String

В этом руководстве по Python String мы обсудим, что такое строка Python и ее примеры. Кроме того, мы узнаем, как объявлять и нарезать строку в Python, а также рассмотрим функции Python String и операции Python String. Наконец, мы рассмотрим escape-последовательности на Python. Как мы видели ранее, вам не нужно указывать тип данных при объявлении строки.

Итак, приступим к уроку Python String.

Python Strings Tutorial — Функции и операции

Learn: побитовый оператор в Python с синтаксисом и примером

2.Что такое строка Python?

Строка Python — это последовательность символов . Имеется встроенный класс str для обработки строки Python. Вы можете доказать это с помощью функции type ().

 >>> type ('Собаки любят') 

<класс «str»>

Python не имеет типа данных char, как C ++ или Java.

Learn: оператор сравнения в Python с синтаксисом и примерами

3. Как объявить строку Python?

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

 >>> a = 'Собаки - это любовь'
>>> print (a) 

Собаки любят

 >>> a = "Собаки - любовь"
>>> print (a) 

Собаки любят

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

 >>> a = 'Собаки - это любовь "

 

SyntaxError: EOL при сканировании строкового литерала

Операторы Python с синтаксисом и примерами

4.Как использовать кавычки внутри строки Python?

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

 >>> a = "Собаки" любят ""
 

SyntaxError: недопустимый синтаксис

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

 >>> a = 'Собаки "любят"'
>>> print (a) 

Собаки «любят»

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

 >>> a = "Собаки любят" "
>>> print (a) 

Собаки «любят»

Тогда вы можете использовать столько кавычек, сколько хотите.

 >>> a = "'Собаки' - это '' любовь '"
>> print (а) 

«Собаки» — это «любовь»

Также обратитесь к разделу 9, чтобы узнать, как избежать кавычек.

Learn: пространство имен Python и область действия переменных — локальные и глобальные переменные

5. Распределение строки по строкам

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

 [php] >>> a = "" "Привет
  Добро пожаловать "" "
>>> print (a) [/ php] 

Hello
Welcome
Он также сохраняет символы новой строки, в отличие от использования для них обратной косой черты.

 >>> a = "Привет \
        Добро пожаловать »
>>> print (а)
 

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

Learn: операторы принятия решений Python с синтаксисом и примерами

6. Как получить доступ к строке Python?

Строка неизменяема; это не может быть изменено.

 >>> a = "Собаки"
>>> a [0] = "H" 

Traceback (последний звонок последний):

Файл «», строка 1, в

a [0] = «H»

TypeError: объект «str» не поддерживает присвоение элемента

Но вы можете получить доступ к строке.

 >>> a = "Собаки - любовь"
>>> а 

«Собаки — это любовь»

 >>> print (a) 

Собаки любят

и. Отображение одного символа

Чтобы отобразить один символ из строки, заключите его индекс в квадратные скобки.Индексирование начинается с 0.

 >>> а [1] 

‘o’

г. Нарезка нити

Иногда может потребоваться отобразить только часть строки. Для этого используйте оператор нарезки [].

 >>> a [3: 8] 

‘s are’

Здесь напечатаны символы с 3 по 7 с индексом, начинающимся с 0.

 >>> a [: 8] 

«Собаки»

Печатает символы от начала до символа 7.

 >>> a [8:] 

«любовь»

Печатает символы от символа 8 до конца строки.

 >>> a [:] 

«Собаки — это любовь»

Печатает всю строку.

 >>> a [: - 2] 

«Собаки ло»

Печатает символы от начала до двух символов меньше конца строки.

 >>> a [-2:] 

ве

Это печатает символы из двух символов от конца до конца строки.

 >>> a [-3: -2] 

‘o’

Это печатает символы от трех символов от конца строки до двух символов от нее.

Следующие коды возвращают пустые строки.

 >>> а [-2: -2] 

 >>> a [2: 2] 

Обучение: циклы в Python с синтаксисом и примерами

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

Конкатенация — это операция объединения материалов.Строки Python могут соединяться с помощью оператора конкатенации +.

 >>> a = 'Ты это видишь?'
>>> b = '$$?'
>>> а + б 

«Вы видите это, $$?»

Возьмем другой пример.

 >>> a = '10 '
>>> print (2 * a) 

1010

Умножение «a» на 2 возвращает 1010, а не 20, потому что «10» — это строка, а не число. Вы не можете объединить строку с числом.

 >>> '10' + 10 

Traceback (последний звонок последний):

Файл «», строка 1, в

’10’ + 10

TypeError: должно быть str, а не int

Обучение: циклы в Python с синтаксисом и примерами

8.Форматировщики строк Python

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

 >>> city = 'Ахмедабад'
>>> print («Возраст», 21, «Город», город) 

Возраст 21 Город Ахмедабад

и. ф-струны

Буква «f» предшествует строке, а переменные упоминаются в фигурных скобках на своих местах.

 >>> name = 'Ayushi'
>>> print (f "Это не день рождения {name}") 

Сегодня не день рождения Аюши

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

ii. format () метод

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

 >>> print ("Я люблю {0}". Format (a)) 

Я люблю собак

 >>> print ("Я люблю {а}".format (a = 'cats')) 

Я люблю кошек

Переменные необязательно определять перед оператором печати.

 >>> print ("Я люблю {b}". Format (b = 'ferrets')) 

Я люблю хорьков

г. % оператор

Оператор% используется там, где переменные идут в строке. % s для строки. За строкой следует оператор и переменные в скобках / в кортеже.

 >>> b = 'хорьки'
>>> print ("Я люблю% s и% s"% (a, b)) 

Я люблю собак и кошек

Другие варианты включают:

% d — для целых

% f — для чисел с плавающей запятой

Learn: функции Python с синтаксисом и примерами

9.Последовательности выхода в Python

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

  • \ n — перевод строки
  • \ t — вкладка
 >>> print ("ад \ к") 

ад о

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

  • \ ’- одинарная кавычка может быть экранирована обратной косой чертой. Это позволяет вам свободно использовать одинарные кавычки в строке.
  • \ ”- Как и одинарная кавычка, двойная кавычка также может быть экранирована.

Есть ли сомнения в отношении строковых операций и функций Python и Python? Прокомментируйте, пожалуйста.

Learn: Аргументы функций Python с типами, синтаксисом и примерами

10. Строковые функции Python

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

а. len ()

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

 >>> a = 'книга'
>>> len (а)
 

4

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

 >>> len (a [2:]) 

2

г. ул ()

Эта функция преобразует любой тип данных в строку.

 >>> str (2 + 3j) 

‘(2 + 3j)’

 >>> str (['красный', 'зеленый', 'синий']) 

«[« красный »,« зеленый »,« синий »]»

г.нижний () и верхний ()

Эти методы возвращают строку в нижнем и верхнем регистре соответственно.

 >>> a = 'Книга'
>>> a.lower () 

«книга»

 >>> a.upper () 

«КНИГА»

г. полоса ()

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

 >>> a = 'Книга'
>>> a.strip () 

«Книга»

эл. isdigit ()

Возвращает True, если все символы в строке являются цифрами.

 >>> а = '777'
>> a.isdigit () 

Правда

 >>> a = '77a'
>>> a.isdigit () 

Ложь

ф. isalpha ()

Возвращает True, если все символы в строке являются символами алфавита.

 >>> a = 'abc'
>>> a.isalpha () 

Правда

 >>> a = 'ab7'
>>> a.isalpha () 

Ложь

г. isspace ()

Возвращает True, если все символы в строке являются пробелами.

 >>> а = ''
>>> a.isspace () 

Правда

 >>> а = '\' '
>>> a.isspace () 

Ложь

ч. начинается с ()

Он принимает строку в качестве аргумента и возвращает True, если строка, к которой он применяется, начинается со строки в аргументе.

 >>> a.startswith ('un') 

Правда

и. заканчивается с ()

Он принимает строку в качестве аргумента и возвращает True, если строка, к которой он применяется, заканчивается строкой в ​​аргументе.

 >>> a = 'поэтому'
>>> a.endswith ('перед') 

Правда

Дж. найти ()

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

 >>> 'homeowner'.find (' мяу ') 

2

Если строка не существует в основной строке, то возвращается индекс 1.

 >>> 'homeowner'.find (' вау ') 
-1
к.replace ()

Требуется два аргумента. Первая — это подстрока, которую нужно заменить. Вторая — это подстрока, которую нужно заменить.

 >>> 'banana'.replace (' na ',' ha ') 

‘bahaha’

л. сплит ()

Требуется один аргумент. Затем строка разбивается вокруг каждого вхождения аргумента в строке.

 >>> 'Нет. Ладно. Почему? '. Split ('. ') 

[«Нет», «Хорошо», «Почему?»]

г. присоединиться ()

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

 >>> "*". Join (['красный', 'зеленый', 'синий']) 

«красный * зеленый * синий»

Learn: Функции Python с синтаксисом и примерами

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

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

а. Сравнение

Python Strings можно сравнивать с помощью операторов отношения.

 >>> 'эй' <'привет' 

Правда

«привет» лексикографически меньше, чем «hi» (потому что i стоит после e в словаре)

 >>> a = 'проверить'
>>> a == 'check' 

Правда

 >>> 'да'! = 'Нет' 

Правда

г.Арифметика

Некоторые арифметические операции можно применять к строкам.

 >>> 'ба' + 'на' * 2 

«банан»

г. Членство

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

 >>> 'na' в 'банане' 

Правда

 >>> 'меньше' не в 'беспомощность' 

Ложь

г. Личность

Операторы идентификации Python «is» и «is not» могут использоваться в строках.

 >>> 'Привет' - это 'Привет' 

Ложь

 >>> Йо - это не йо 

Правда

e. Логический

Python операторы and, or, and not также могут применяться. Пустая строка имеет логическое значение False.

1. и - Если значение слева - Истина, возвращается значение справа. В противном случае значение слева - False, оно возвращает False.

 >>> '' и '1' 

 >>> '1' и '


2.или - Если значение слева - Истина, возвращается Истина. В противном случае возвращается значение справа.

3. not- Как мы говорили ранее, пустая строка имеет логическое значение False.

 >>> not ('1') 

Ложь

 >>> не ('') 

Правда

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

12. Строка Python - Заключение

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

Проверка Необходимо прочитать книги Python для программирования на Python

.

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

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