Функции работы со строками питон: работа со строками, форматирование,методы 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. Это относится и к срезу.

Опять же, второй индекс указывает символ, который не включен в результат. Символ 'n' в приведенном выше примере. Это может показаться немного не интуитивным, но дает результат: выражение s[m:n] вернет подстроку, которая является разницей n - m, в данном случае 5 - 2 = 3

.

Если пропустить первый индекс, срез начинается с начала строки. Таким образом, s[:m] = s[0:m]:

>>> s = 'python'
>>> s[:4]
'pyth'
>>> s[0:4]
'pyth'

Аналогично, если опустить второй индекс s[n:], срез длится от первого индекса до конца строки. Это хорошая, лаконичная альтернатива более громоздкой s[n:len(s)]:

>>> s = 'python'
>>> s[2:]
'thon'
>>> s[2:len(s)]
'thon'

Для любой строки s и любого целого n числа (0 ≤ n ≤ len(s)), s[:n] + s[n:]будет s:

>>> s = 'python'
>>> s[:4] + s[4:]
'python'
>>> s[:4] + s[4:] == s
True

Пропуск обоих индексов возвращает исходную строку. Это не копия, это ссылка на исходную строку:

>>> s = 'python'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

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

>>> s[2:2]
''
>>> s[4:2]
''

Отрицательные индексы можно использовать и со срезами. Вот пример кода Python:

>>> s = 'python'
>>> s[-5:-2]
'yth'
>>> s[1:4]
'yth'
>>> s[-5:-2] == s[1:4]
True

Шаг для среза строки

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

Например , для строки 'python' срез 0:6:2 начинается с первого символа и заканчивается последним символом (всей строкой), каждый второй символ пропускается. Это показано на следующей схеме:

Иллюстративный код показан здесь:

>>> s = 'foobar'
>>> s[0:6:2]
'foa'
>>> s[1:6:2]
'obr'

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

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'

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

>>> s = 'python'
>>> s[5:0:-2]
'nhy'

В приведенном выше примере, 5:0:-2 означает «начать с последнего символа и делать два шага назад, но не включая первый символ.”

Когда вы идете назад, если первый и второй индексы пропущены, значения по умолчанию применяются так: первый индекс — конец строки, а второй индекс — начало. Вот пример:

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'

Это общая парадигма для разворота (reverse) строки:

>>> s = 'Если так говорит товарищ Наполеон, значит, так оно и есть.'
>>> s[::-1]
'.ьтсе и оно кат ,тичанз ,ноелопаН щиравот тировог кат илсЕ'

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

В Python версии 3.6 был представлен новый способ форматирования строк. Эта функция официально названа литералом отформатированной строки, но обычно упоминается как f-string.

Возможности форматирования строк огромны и не будут подробно описана здесь.
Одной простой особенностью f-строк, которые вы можете начать использовать сразу, является интерполяция переменной. Вы можете указать имя переменной непосредственно в f-строковом литерале (f'string'), и python заменит имя соответствующим значением.

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

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('Произведение', n, 'на', m, 'равно', prod)
Произведение 20 на 25 равно 500

Но это громоздко. Чтобы выполнить то же самое с помощью f-строки:

  • Напишите f или F перед кавычками строки. Это укажет python, что это f-строка вместо стандартной.
  • Укажите любые переменные для воспроизведения в фигурных скобках ({}).

Код с использованием f-string, приведенный ниже выглядит намного чище:

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'Произведение {n} на {m} равно {prod}')
Произведение 20 на 25 равно 500

Любой из трех типов кавычек в python можно использовать для f-строки:

>>> var = 'Гав'
>>> print(f'Собака говорит {var}!')
Собака говорит Гав!
>>> print(f"Собака говорит {var}!")
Собака говорит Гав!
>>> print(f'''Собака говорит {var}!''')
Собака говорит Гав!

Изменение строк

Строки — один из типов данных, которые Python считает неизменяемыми, что означает невозможность их изменять. Как вы ниже увидите, python дает возможность изменять (заменять и перезаписывать) строки.

Такой синтаксис приведет к ошибке TypeError:

>>> s = 'python'
>>> s[3] = 't'
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    s[3] = 't'
TypeError: 'str' object does not support item assignment

На самом деле нет особой необходимости изменять строки. Обычно вы можете легко сгенерировать копию исходной строки с необходимыми изменениями. Есть минимум 2 способа сделать это в python. Вот первый:

>>> s = s[:3] + 't' + s[4:]
>>> s
'pytton'

Есть встроенный метод string.replace(x, y):

>>> s = 'python'
>>> s = s.replace('h', 't')
>>> s
'pytton'

Читайте дальше о встроенных методах строк!

Встроенные методы строк в python

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

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

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

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

obj.foo(<args>)

Этот код вызывает метод .foo() объекта obj. <args> — аргументы, передаваемые методу (если есть).

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

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

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

Методы этой группы выполняют преобразование регистра строки.

string.capitalize() приводит первую букву в верхний регистр, остальные в нижний.

s.capitalize() возвращает копию s с первым символом, преобразованным в верхний регистр, и остальными символами, преобразованными в нижний регистр:

>>> s = 'everyTHing yoU Can IMaGine is rEAl'
>>> s.capitalize()
'Everything you can imagine is real'

Не алфавитные символы не изменяются:

>>> s = 'follow us @PYTHON'
>>> s.capitalize()
'Follow us @python'

string.lower() преобразует все буквенные символы в строчные.

s.lower() возвращает копию s со всеми буквенными символами, преобразованными в нижний регистр:

>>> 'everyTHing yoU Can IMaGine is rEAl'. lower()
'everything you can imagine is real'

string.swapcase() меняет регистр буквенных символов на противоположный.

s.swapcase() возвращает копию s с заглавными буквенными символами, преобразованными в строчные и наоборот:

>>> 'everyTHing yoU Can IMaGine is rEAl'.swapcase()
'EVERYthING YOu cAN imAgINE IS ReaL'

string.title() преобразует первые буквы всех слов в заглавные

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

>>> 'the sun also rises'.title()
'The Sun Also Rises'

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

>>> 'follow us @PYTHON'.title()
'Follow Us @Python'

string.upper() преобразует все буквенные символы в заглавные.

s.upper() возвращает копию s со всеми буквенными символами в верхнем регистре:

>>> 'follow us @PYTHON'.upper()
'FOLLOW US @PYTHON'

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

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

Каждый метод в этой группе поддерживает необязательные аргументы <start> и <end> аргументы. Они задают диапазон поиска: действие метода ограничено частью целевой строки, начинающейся в позиции символа <start> и продолжающейся вплоть до позиции символа <end>, но не включая его. Если <start> указано, а <end> нет, метод применяется к части строки от <start> конца.

string.count(<sub>[, <start>[, <end>]]) подсчитывает количество вхождений подстроки в строку.

s.count(<sub>) возвращает количество точных вхождений подстроки <sub> в s:

>>> 'foo goo moo'.count('oo')
3

Количество вхождений изменится, если указать <start> и <end>:

>>> 'foo goo moo'.count('oo', 0, 8)
2

string.endswith(<suffix>[, <start>[, <end>]]) определяет, заканчивается ли строка заданной подстрокой.

s.endswith(<suffix>) возвращает, True если s заканчивается указанным <suffix> и False если нет:

>>> 'python'.endswith('on')
True
>>> 'python'.endswith('or')
False

Сравнение ограничено подстрокой, между <start> и <end>, если они указаны:

>>> 'python'.endswith('yt', 0, 4)
True
>>> 'python'.endswith('yt', 2, 4)
False

string.find(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку.

s.find(<sub>) возвращает первый индекс в s который соответствует началу строки <sub>:

>>> 'Follow Us @Python'.find('Us')
7

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

>>> 'Follow Us @Python'.find('you')
-1

Поиск в строке ограничивается подстрокой, между <start> и <end>, если они указаны:

>>> 'Follow Us @Python'.find('Us', 4)
7
>>> 'Follow Us @Python'.find('Us', 4, 7)
-1

string.index(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку.

Этот метод идентичен .find(), за исключением того, что он вызывает исключение ValueError, если <sub> не найден:

>>> 'Follow Us @Python'.index('you')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'Follow Us @Python'.index('you')
ValueError: substring not found

string.rfind(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.

s.rfind(<sub>) возвращает индекс последнего вхождения подстроки <sub> в s, который соответствует началу <sub>:

>>> 'Follow Us @Python'.rfind('o')
15

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

>>> 'Follow Us @Python'.rfind('a')
-1

Поиск в строке ограничивается подстрокой, между <start> и <end>, если они указаны:

>>> 'Follow Us @Python'.rfind('Us', 0, 14)
7
>>> 'Follow Us @Python'.rfind('Us', 9, 14)
-1

string.rindex(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.

Этот метод идентичен .rfind(), за исключением того, что он вызывает исключение ValueError, если <sub> не найден:

>>> 'Follow Us @Python'.rindex('you')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'Follow Us @Python'.rindex('you')
ValueError: substring not found

string.startswith(<prefix>[, <start>[, <end>]]) определяет, начинается ли строка с заданной подстроки.

s.startswith(<suffix>) возвращает, True если s начинается с указанного <suffix> и False если нет:

>>> 'Follow Us @Python'.startswith('Fol')
True
>>> 'Follow Us @Python'.startswith('Go')
False

Сравнение ограничено подстрокой, между <start> и <end>, если они указаны:

>>> 'Follow Us @Python'.startswith('Us', 7)
True
>>> 'Follow Us @Python'.startswith('Us', 8, 16)
False

Классификация строк

Методы в этой группе классифицируют строку на основе символов, которые она содержит.

string.isalnum() определяет, состоит ли строка из букв и цифр.

s.isalnum() возвращает True, если строка s не пустая, а все ее символы буквенно-цифровые (либо буква, либо цифра). В другом случае False :

>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

string.isalpha() определяет, состоит ли строка только из букв.

s.isalpha() возвращает True, если строка s не пустая, а все ее символы буквенные. В другом случае False:

>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

string.isdigit() определяет, состоит ли строка из цифр (проверка на число).

s.digit() возвращает True когда строка s не пустая и все ее символы являются цифрами, а в False если нет:

>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

string.isidentifier() определяет, является ли строка допустимым идентификатором Python.

s.isidentifier() возвращает True, если s валидный идентификатор (название переменной, функции, класса и т.д.) python, а в False если нет:

>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

Важно: .isidentifier() вернет True для строки, которая соответствует зарезервированному ключевому слову python, даже если его нельзя использовать:

>>> 'and'.isidentifier()
True

Вы можете проверить, является ли строка ключевым словом Python, используя функцию iskeyword(), которая находится в модуле keyword. Один из возможных способов сделать это:

>>> from keyword import iskeyword
>>> iskeyword('and')
True

Если вы действительно хотите убедиться, что строку можно использовать как идентификатор python, вы должны проверить, что .isidentifier() = True и iskeyword() = False.

string.islower() определяет, являются ли буквенные символы строки строчными.

s.islower() возвращает True, если строка s не пустая, и все содержащиеся в нем буквенные символы строчные, а False если нет. Не алфавитные символы игнорируются:

>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

string.isprintable() определяет, состоит ли строка только из печатаемых символов.

s.isprintable() возвращает, True если строка s пустая или все буквенные символы которые она содержит можно вывести на экран. Возвращает, False если s содержит хотя бы один специальный символ. Не алфавитные символы игнорируются:

>>> 'a\tb'.isprintable() 
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable() 
False

Важно: Это единственный .is****() метод, который возвращает True, если s пустая строка. Все остальные возвращаются False.

string.isspace() определяет, состоит ли строка только из пробельных символов.

s.isspace() возвращает True, если s не пустая строка, и все символы являются пробельными, а False, если нет.

Наиболее часто встречающиеся пробельные символы — это пробел ' ', табуляция '\t' и новая строка '\n':

>>> ' \t  \n '.isspace()
True
>>> ' a '.isspace()
False

Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:

>>> '\f\u2005\r'.isspace()
True

'\f' и '\r' являются escape-последовательностями для символов ASCII; '\u2005' это escape-последовательность для Unicode.

string.istitle() определяет, начинаются ли слова строки с заглавной буквы.

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

>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

string.isupper() определяет, являются ли буквенные символы строки заглавными.

s.isupper() возвращает True, если строка s не пустая, и все содержащиеся в ней буквенные символы являются заглавными, и в False, если нет. Не алфавитные символы игнорируются:

>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False

Выравнивание строк, отступы

Методы в этой группе влияют на вывод строки.

string.center(<width>[, <fill>]) выравнивает строку по центру.

s.center(<width>) возвращает строку, состоящую из s выровненной по ширине <width>. По умолчанию отступ состоит из пробела ASCII:

>>> 'py'.center(10)
'    py    '

Если указан необязательный аргумент <fill>, он используется как символ заполнения:

>>> 'py'.center(10, '-')
'----py----'

Если s больше или равна <width>, строка возвращается без изменений:

>>> 'python'.center(2)
'python'

string.expandtabs(tabsize=8) заменяет табуляции на пробелы

s.expandtabs() заменяет каждый символ табуляции ('\t') пробелами. По умолчанию табуляция заменяются на 8 пробелов:

>>> 'a\tb\tc'.expandtabs()
'a       b       c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa     bbb     c'

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

>>> 'a\tb\tc'.expandtabs(4)
'a   b   c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'

string.ljust(<width>[, <fill>]) выравнивание по левому краю строки в поле.

s.ljust(<width>) возвращает строку s, выравненную по левому краю в поле шириной <width>. По умолчанию отступ состоит из пробела ASCII:

>>> 'python'.ljust(10)
'python    '

Если указан аргумент <fill> , он используется как символ заполнения:

>>> 'python'.ljust(10, '-')
'python----'

Если s больше или равна <width>, строка возвращается без изменений:

>>> 'python'.ljust(2)
'python'

string.lstrip([<chars>]) обрезает пробельные символы слева

s.lstrip()возвращает копию s в которой все пробельные символы с левого края удалены:

>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'

Необязательный аргумент <chars>, определяет набор символов, которые будут удалены:

>>> 'https://www.pythonru.com'.lstrip('/:pths')
'www.pythonru.com'

string.replace(<old>, <new>[, <count>]) заменяет вхождения подстроки в строке.

s.replace(<old>, <new>) возвращает копию s где все вхождения подстроки <old>, заменены на <new>:

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love')
'I love python! I love python! I love python!'

Если указан необязательный аргумент <count>, выполняется количество <count> замен:

>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love', 2)
'I love python! I love python! I hate python!'

string.rjust(<width>[, <fill>]) выравнивание по правому краю строки в поле.

s.rjust(<width>) возвращает строку s, выравненную по правому краю в поле шириной <width>. По умолчанию отступ состоит из пробела ASCII:

>>> 'python'.rjust(10)
'    python'

Если указан аргумент <fill> , он используется как символ заполнения:

>>> 'python'.rjust(10, '-')
'----python'

Если s больше или равна <width>, строка возвращается без изменений:

>>> 'python'.rjust(2)
'python'

string.rstrip([<chars>]) обрезает пробельные символы справа

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

>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'

Необязательный аргумент <chars>, определяет набор символов, которые будут удалены:

>>> 'foo.$$$;'.rstrip(';$.')
'foo'

string.strip([<chars>]) удаляет символы с левого и правого края строки.

s.strip() эквивалентно последовательному вызову s.lstrip()и s.rstrip(). Без аргумента <chars> метод удаляет пробелы в начале и в конце:

>>> s = '   foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'

Как в .lstrip() и .rstrip(), необязательный аргумент <chars> определяет набор символов, которые будут удалены:

>>> 'www.pythonru.com'.strip('w.moc')
'pythonru'

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

>>> '   foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar baz\t\t\t'.strip()
'foo bar baz'

>>> 'www.pythonru.com'.lstrip('w.').rstrip('.moc')
'pythonru'
>>> 'www.pythonru.com'.strip('w.moc')
'pythonru'

string.zfill(<width>) дополняет строку нулями слева.

s.zfill(<width>) возвращает копию s дополненную '0' слева для достижения длины строки указанной в <width>:

>>> '42'.zfill(5)
'00042'

Если s содержит знак перед цифрами, он остается слева строки:

>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'

Если s больше или равна <width>, строка возвращается без изменений:

>>> '-42'.zfill

10 приемов для преобразования и декомпозиции строк в Python

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

Никто не может отрицать важность анализа текста и синтаксического анализа строк. Он применяется практически во всех направлениях разработки программного обеспечения, от парсинга URL-адресов до обработки естественного языка. Мы не будем описывать все возможные его применения  — это выходит далеко за рамки одной статьи. Но о некоторых базовых методах работы со строками и токенами в Python мы расскажем.

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

А теперь давайте перейдем к нашему списку!


1. Translate и Replace

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

Метод translate() использует таблицу (которая строится при помощи функции maketrans) для удаления или изменения определенных символов:

test_string = 'The quick brown fox jumps over the lazy dog' 
translation_map = str.maketrans('eo', '  ') 
test_string.translate( translation_map ) 

Out[1]: 'Th  quick br wn f x jumps  v r th  lazy d g'

Метод replace() работает так, как следует из его названия — изменяя подстроку на нужную:

test_string = 'The quick brown fox jumps over the lazy dog'
test_string.replace( 'fox', 'squirell')

Out[2]: 'The quick brown squirell jumps over the lazy dog'

2. Очистка строки

Теперь мы можем применить информацию из предыдущего пункта для очистки строки. Это один из наиболее востребованных процессов в проектах data science при очистке данных. Отличный пример — это необработанный текст с пробельными символами и переносами строк. Вот простой скрипт для очистки такой строки:

test_string_with_garbage = 'The quick brown fox\njumps\tover the\tlazy dog\r\n'
character_map = {
 ord('\n') : ' ',
 ord('\t') : ' ',
 ord('\r') : None
}
test_string_with_garbage.translate(character_map)

Out[3]: 'The quick brown fox jumps over the lazy dog '

3. Разбиение строки

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

  • Разбиение по пробелу (по умолчанию):
test_string.split()
Out[1]: ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']
  • Разбиение на определенное количество токенов:
test_string.split(' ', 2)
Out[2]: ['The', 'quick', 'brown fox jumps over the lazy dog']
  • Разбиение на определенное количество токенов в обратном направлении:
test_string.rsplit(' ', 2)
Out[3]: ['The quick brown fox jumps over the', 'lazy', 'dog']
  • Разбиение по произвольному символу:
test_string.split('e')
Out[4]: ['Th', ' quick brown fox jumps ov', 'r the lazy dog']
  • Разбиение строки по нужному токену с токенами до и после него:
test_string.partition('fox')
Out[5]: ('The quick brown ', 'fox', ' jumps over the lazy dog')

4. Strip и zfill

Еще одна важная функция — это возможность удалять из строки лишние начальные и конечные символы. Для этого у нас есть семейство функций strip():

  • Удалить пробелы по умолчанию.
  • Удалить пробелы слева или справа.
  • Удалить произвольные символы.
test_string_with_spaces = '     The quick brown fox jumps over the lazy dog    '
test_string_with_spaces.strip()

Out[1]: 'The quick brown fox jumps over the lazy dog'

test_string_with_spaces.lstrip()

Out[2]: 'The quick brown fox jumps over the lazy dog    '

test_string_with_spaces.rstrip()

Out[3]: '     The quick brown fox jumps over the lazy dog'

test_string.rstrip('g')

Out[4]: 'The quick brown fox jumps over the lazy do'

Кроме того, есть полезная функция для дополнения чисел ведущими нулями:

'29'.zfill(10)

Out[1]: '0000000029'

'xA1'.zfill(4)

Out[2]: '0xA1'

5. Деконструкция и реконструкция

Для генерации текста необходимо построить предложения и фразы из словаря слов. Этот процесс обратный разделению строки. Python позволяет нам использовать встроенный строковый метод join() для объединения слов обратно в предложение:

test_array = test_string.split()
# ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']

''.join(test_array)

Out[1]: 'Thequickbrownfoxjumpsoverthelazydog'

' '.join(test_array)

Out[2]: 'The quick brown fox jumps over the lazy dog'

6. Удаление знаков препинания

Это еще один случай очистки текста. Модуль string в Python имеет множество встроенных констант с отдельными наборами символов. string.punctuation — один из них, поэтому мы будем использовать его для очистки строки.

test_punctuation = "  This &is [an] example? {of} string. with.? punctuation!!!!  "

import string
test_punctuation.translate(str.maketrans('', '', string.punctuation))

Out[1]: 'This is an example of string with punctuation'

7. Работа с регистрами

Форматирование текста — это боль каждого data scientist’а. Слова и предложения в разных форматах создают много проблем при очистке данных. Однако и для этих задач в Python есть нужные функции:

test_string.lower()
Out[1]: 'the quick brown fox jumps over the lazy dog'

test_string.upper()
Out[2]: 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG'

test_string.title()
Out[3]: 'The Quick Brown Fox Jumps Over The Lazy Dog'

test_string.title().swapcase()
Out[4]: 'tHE qUICK bROWN fOX jUMPS oVER tHE lAZY dOG'

test_string.title().swapcase().capitalize()
Out[5]: 'The quick brown fox jumps over the lazy dog'

8. Мир регулярных выражений

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

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

Разделение по шаблону:

import re
test_punctuation = "  This &is [an] example? {of} string. with.? punctuation!!!!  "
re.split('\W+', test_punctuation)

Out[1]: ['This', 'is', 'an', 'example', 'of', 'string', 'with', 'punctuation', '']

Замена по шаблону:

import re
test_with_numbers = "This is 1 string with 10 words for 9 digits 2 example"
re.sub('\d', '*', test_with_numbers)

Out[1]: 'This is * string with ** words for * digits * example'

9. Токенизация строки

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

import pandas as pd
test_punctuation = "  This &is [an] example? {of} string. with.? punctuation!!!!  "
data = pd.DataFrame([test_punctuation])

data.iloc[0].str.lower().str.replace('\W+', ' ').str.strip().str.split()

Out[1]:  [this, is, an, example, of, string, with, punctuation]
         Name: 0, dtype: object

10. Поиск подстроки

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

  • Заканчивается ли строка указанной подстрокой:
test_string.endswith('dog')
Out[1]: True
  • Начинается ли строка с указанной подстроки:
test_string.startswith('dog')
Out[2]: False
  • Содержит ли строка указанную подстроку:
'fox' in test_string
Out[3]: True
  • Получение индекса подстроки:
test_string.find('fox')
Out[4]: 16

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

Новый улучшенный способ форматирования строк в Python

У нас для вас хорошие новости: f-строки вступают в дело, чтобы помочь с форматированием. Также известные как «форматированные строковые литералы», f-strings являются строковыми литералами с «f» в начале и фигурные скобки, содержащие выражения, которые в дальнейшем будут заменены своими значениями. Выражения оцениваются по мере выполнения и затем форматируются при помощи протокола __format__ . Как всегда, документация Python может помочь, если хотите узнать больше.

Совет от администрации: Как не потратить каникулы в пустую?

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

Отвечаем сразу всем кто пишет нам в Telegram «С чего начать изучение Python?». Вот курс, пройдите его!

Получите сертификат!
И вы будете на голову выше остальных кандидатов!

Рассмотрим подробнее, как именно f-strings могут упростить вам жизнь.

Простой синтаксис

Синтаксис аналогичен тому, который вы используете в str.format(), но не такой перегруженный. Посмотрите на эту читабельность:

name = «Eric» age = 74 print(f»Hello, {name}. You are {age}.») # Вывод: ‘Hello, Eric. You are 74.’

name = «Eric»

age = 74

 

print(f»Hello, {name}. You are {age}.»)

# Вывод: ‘Hello, Eric. You are 74.’

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

print(F»Hello, {name}. You are {age}.») # Вывод: ‘Hello, Eric. You are 74.’

print(F»Hello, {name}. You are {age}.»)

# Вывод: ‘Hello, Eric. You are 74.’

Вам уже нравится? Надеемся, что да, в любом случае, вы будете в восторге к концу статьи.

Произвольные выражения

Так как f-строки оцениваются по мере выражения, вы можете внести любую или все доступные выражения Python в них. Это позволит вам делать интересные вещи, например следующее:

print(f»{2 * 37}») # Вывод: ’74’

print(f»{2 * 37}»)

# Вывод: ’74’

Также вы можете вызывать функции. Пример:

def to_lowercase(input): return input.lower() name = «Eric Idle» print(f»{to_lowercase(name)} is funny.») # Вывод: ‘eric idle is funny.’

def to_lowercase(input):

    return input.lower()

 

name = «Eric Idle»

 

print(f»{to_lowercase(name)} is funny.»)

# Вывод: ‘eric idle is funny.’

Также вы можете вызывать метод напрямую:

print(f»{name.lower()} is funny.») # Вывод: ‘eric idle is funny.’

print(f»{name.lower()} is funny.»)

# Вывод: ‘eric idle is funny.’

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

class Comedian: def __init__(self, first_name, last_name, age): self.first_name = first_name self.last_name = last_name self.age = age def __str__(self): return f»{self.first_name} {self.last_name} is {self.age}.» def __repr__(self): return f»{self.first_name} {self.last_name} is {self.age}. Surprise!»

class Comedian:

    def __init__(self, first_name, last_name, age):

        self.first_name = first_name

        self.last_name = last_name

        self.age = age

 

    def __str__(self):

        return f»{self.first_name} {self.last_name} is {self.age}.»

 

    def __repr__(self):

        return f»{self.first_name} {self.last_name} is {self.age}. Surprise!»

Вы могли бы сделать следующее:

new_comedian = Comedian(«Eric», «Idle», «74») print(f»{new_comedian}») # Вывод: ‘Eric Idle is 74.’

new_comedian = Comedian(«Eric», «Idle», «74»)

 

print(f»{new_comedian}»)

# Вывод: ‘Eric Idle is 74.’

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

Строка, которая возвращается __str__() является неформальным строковым представлением объекта и должна быть читаемой. Строка, которую вернул __str__() — это официальное выражение и должно быть однозначным. При вызове str() и repr(), предпочтительнее использовать __str__() и __repr__() напрямую.

По умолчанию, f-строки будут использовать __str__(), но вы должны убедиться в том, что они используют __repr__(), если вы включаете флаг преобразования !r:

print(f»{new_comedian}») # Вывод: ‘Eric Idle is 74.’ print(f»{new_comedian!r}») # Вывод: ‘Eric Idle is 74. Surprise!’

print(f»{new_comedian}»)

# Вывод: ‘Eric Idle is 74.’

 

print(f»{new_comedian!r}»)

# Вывод: ‘Eric Idle is 74. Surprise!’

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

Многострочные F-Strings

У вас могут быть многострочные f-strings:

name = «Eric» profession = «comedian» affiliation = «Monty Python» message = ( f»Hi {name}. « f»You are a {profession}. « f»You were in {affiliation}.» ) print(message) # Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

name = «Eric»

profession = «comedian»

affiliation = «Monty Python»

 

message = (

    f»Hi {name}. «

    f»You are a {profession}. «

    f»You were in {affiliation}.»

)

 

print(message)

# Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

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

message = ( f»Hi {name}. « «You are a {profession}. « «You were in {affiliation}.» ) print(message) # Вывод: ‘Hi Eric. You are a {profession}. You were in {affiliation}.’

message = (

    f»Hi {name}. «

    «You are a {profession}. «

    «You were in {affiliation}.»

)

 

print(message)

# Вывод: ‘Hi Eric. You are a {profession}. You were in {affiliation}.’

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

Если вы хотите размножить строки по нескольким линиям, у вас также есть возможность избежать возвратов при помощи \:

message = f»Hi {name}. » \ f»You are a {profession}. » \ f»You were in {affiliation}.» print(message) # Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

message = f»Hi {name}. » \

          f»You are a {profession}. » \

          f»You were in {affiliation}.»

 

print(message)

# Вывод: ‘Hi Eric. You are a comedian. You were in Monty Python.’

Но вот что произойдет, если вы используете «»»:

message = f»»» Hi {name}. You are a {profession}. You were in {affiliation}. «»» print(message) # Вывод: ‘\n Hi Eric.\n You are a comedian.\n You were in Monty Python.\n’

message = f»»»

    Hi {name}.

    You are a {profession}.

    You were in {affiliation}.

«»»

 

print(message)

# Вывод: ‘\n    Hi Eric.\n    You are a comedian.\n    You were in Monty Python.\n’

Инструкция по отступам доступна в PEP 8.

Скорость

Буква f в f-strings может также означать и “fast”. Наши f-строки заметно быстрее чем % и str.format() форматирования. Как мы уже видели, f-строки являются выражениями, которые оцениваются по мере выполнения, а не постоянные значения. Вот выдержка из документации:

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

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

Рассмотрим сравнение скорости:

>>> import timeit >>> timeit.timeit(«»»name = «Eric» … age = 74 … ‘%s is %s.’ % (name, age)»»», number = 10000) 0.003324444866599663

>>> import timeit

>>> timeit.timeit(«»»name = «Eric»

… age = 74

… ‘%s is %s.’ % (name, age)»»», number = 10000)

 

0.003324444866599663

>>> timeit.timeit(«»»name = «Eric» … age = 74 … ‘{} is {}.’.format(name, age)»»», number = 10000) 0.004242089427570761

>>> timeit.timeit(«»»name = «Eric»

… age = 74

… ‘{} is {}.’.format(name, age)»»», number = 10000)

 

0.004242089427570761

>>> timeit.timeit(«»»name = «Eric» … age = 74 … f'{name} is {age}.'»»», number = 10000) 0.0024820892040722242

>>> timeit.timeit(«»»name = «Eric»

… age = 74

… f'{name} is {age}.'»»», number = 10000)

 

0.0024820892040722242

Как вы видите, f-строки являются самыми быстрыми.

Однако, суть не всегда в этом. После того, как они реализуются первыми, у них есть определенные проблемы со скоростью и их нужно сделать быстрее, чем str.format(). Для этого был предоставлен специальный опкод BUILD_STRING.

Python F-Строки: Детали

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

Кавычки

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

Этот код будет работать:

print(f»{‘Eric Idle’}») # Вывод: ‘Eric Idle’

print(f»{‘Eric Idle’}»)

# Вывод: ‘Eric Idle’

И этот тоже:

print(f'{«Eric Idle»}’) # Вывод: ‘Eric Idle’

print(f'{«Eric Idle»}’)

# Вывод: ‘Eric Idle’

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

print(f»»»Eric Idle»»») # Вывод: ‘Eric Idle’

print(f»»»Eric Idle»»»)

# Вывод: ‘Eric Idle’

print(f»’Eric Idle»’) # Вывод: ‘Eric Idle’

print(f»’Eric Idle»’)

# Вывод: ‘Eric Idle’

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

print(f»The \»comedian\» is {name}, aged {age}.») # Вывод: ‘The «comedian» is Eric Idle, aged 74.’

print(f»The \»comedian\» is {name}, aged {age}.»)

# Вывод: ‘The «comedian» is Eric Idle, aged 74.’

Словари

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

Вот так:

comedian = {‘name’: ‘Eric Idle’, ‘age’: 74} print(f»The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.») # Вывод: The comedian is Eric Idle, aged 74.

comedian = {‘name’: ‘Eric Idle’, ‘age’: 74}

 

print(f»The comedian is {comedian[‘name’]}, aged {comedian[‘age’]}.»)

# Вывод: The comedian is Eric Idle, aged 74.

SyntaxError: invalid syntax

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

Скобки

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

print(f»{{74}}») # Вывод: ‘{ 74 }’

print(f»{{74}}»)

 

# Вывод: ‘{ 74 }’

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

print( f»{{{74}}}» ) # Вывод: ‘{ 74 }’

print( f»{{{74}}}» )

 

# Вывод: ‘{ 74 }’

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

print(f»{{{{74}}}}») # Вывод: ‘{{74}}’

print(f»{{{{74}}}}»)

 

# Вывод: ‘{{74}}’

Бэкслеши

Как вы видели ранее, вы можете использовать бэкслеши в части строки f-string.

SyntaxError: f-string expression part cannot include ‘#’

Идите с миром и форматируйте!

Разумеется, вы можете использовать старые методы форматирования строк, но с f-строками у вас есть более лаконичный, читаемый и удобный способ, который одновременно и быстрее, и менее вероятно приведет к ошибке. Упростить свою жизнь используя f-строки — отлична причина пользоваться Python 3.6, если вы еще не перешли к этой версии. (Если вы все еще пользуетесь Python 2.7, не беспокойтесь, 2020 год не за горами!)

Согласно дзену Python, когда вам нужно выбрать способ решения задачи, всегда “есть один — и желательно только один очевидный способ сделать это”. Кстати, f-строки не являются единственным способом форматирования строк. Однако, их использование вполне может стать единственным адекватным способом.

Python. Строки. Общие понятия. Операции над строками. Примеры

Строки. Общие понятия. Объявление строки. Операции над строками. Примеры


Содержание


Поиск на других ресурсах:

1. Определение строки. Назначение строк

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

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

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

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

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

"Hello world!"
'bestprog.net'
'1234567890'
"1234567890"
"I'm" # строка I'm - одинарные кавычки в двойных кавычках
'I"m' # строка I"m - двойные кавычки в одинарных кавычках

  ⇑

2. Какие строковые типы поддерживаются в Python?

В языке Python поддерживаются три типа строк:

  • строки типа str – предназначенные для представления текста в формате Unicode и других системах кодирования. Этот формат содержит символы в кодировке ASCII и символы в других кодировках;
  • строки типа bytes – предназначенные для представления двоичных данных;
  • строки типа bytearray – предназначенные для представления двоичных данных с учетом изменений в типе bytes.

В версии Python 2.6 для представления текста Unicode используется тип unicode.

  ⇑

3. Как объявить переменную типа «строка»? Общая форма

Чтобы объявить переменную типа строка достаточно использовать оператор присваивания =. Общая форма объявления переменной следующая

variable_name = string

где

  • variable_name – имя создаваемой переменной. В дальнейшем это имя используется в программе и связано со строкой string;
  • string – строка (литерал), размещенная между одинарными или двойными кавычки.


  ⇑

4. Примеры объявления строковых переменных

 

a = 'abcde' # объявление с помощью одинарной кавычки
b = "abcde" # объявление с помощью двойной кавычки
line = '' # пустая строка
block_s = """abcde""" # блок в тройной кавычке
s1 = b'hello' # строка байт в версиях 3.0 и старше
s2 = u'hello' # строка с символами Unicode
s3 = 's\np\ta\x00m' # экранированные последовательности
s4 = r'c:\myfolder\myfile1.txt' # неформатированная строка

  ⇑

5. Существует ли в Python тип, который описывает одиночный символ (например char)?

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

firstLetter = 'A'
lastLetter = 'Z'
zero = '0'

  ⇑

6. Базовые операторы для работы со строками. Таблица

Над строками можно выполнять типичные операции. Для этого в языке Python перегружены соответствующие операторы.

Ниже в таблице приведен перечень операторов для работы с строками.

Оператор (операция) Использование в программах Объяснение
+ s1+s2 Конкатенация
* s*2 Повторение
[ ] s[i] Обращение к символу строки s по индексу i
[:] s[i:j] Вытягивание подстроки из позиции i до позиции j

  ⇑

7. Пример использования оператора + конкатенации (сложение) строк

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

Пример.

# Оператор конкатенации - сложение строк
s1 = 'Hello'
s2 = 'world!'
s3 = s1 + ' ' + s2 # s3 = 'Hello world!'

  ⇑

8. Пример использования оператора * повторения строк

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

Пример. В примере строка s2 равна трем строкам s1

# Оператор повторения строк *
s1 = 'abc'
s2 = s1*3 # 'abcabcabc'

  ⇑

9. Пример использования оператора [] вытягивания элемента строки по ее индексу

Чтобы получить один символ строки, используется операция индексирования []. Ниже приведены примеры получения символа строки по ее индексу. Нумерация индексов начинается с 0.

Пример. В примере переменной c присваивается символ с индексом [1] строки s.

# Оператор [] - вытягивание символа в строке по ее индексу
s1 = 'abc'
c = s1[1] # c = 'b'

  ⇑

10. Пример использования оператора [:] вытягивания подстроки из строки

Оператор [:] используется для обработки подстрок в строках. Этот оператор имеет много разновидностей. Более подробно о работе оператора [:] описывается здесь. В данной теме приведены несколько ограниченных примеров использования оператора вытягивания строки из подстроки.

Пример.

# Оператор [:] - вытягивание символа в строке по индексу
s1 = '01234567890'
s2 = s1[2:4] # s2 = '23'
s3 = s1[:5] # s3 = '01234'
s4 = s1[:-1] # s4 = '0123456789'

  ⇑

11. Пример обхода строки с помощью оператора цикла for

В примере демонстрируется просмотр всех символов строки с помощью оператора цикла for. Решается задача просмотра количества символов ‘z’ в строке. Строка вводится с клавиатуры.

# Строки
# Пример обхода элементов строки в цикле

# 1. Ввод строки
s = str(input("Enter string: "))

# 2. Вывод строки для проверки - цикл обхода строки
for c in s:
    print(c, end=' ') # посимвольный вывод строки
print()

# 3. Определение количества символов 'z' в строке
count = 0;
for c in s:
    if c=='z':
        count = count+1

# вывод результата
print("count = ", count)

Результат выполнения программы

Enter string: zero z1sdlkj 12+laksd
z e r o   z 1 s d l k j   1 2 + l a k s d
count = 2

  ⇑


Связанные темы

  ⇑


 

строки, сравнения строк, базовые функции str, len, ord, in

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

str1 = 'Hello1'
str2 = "Hello2"

А другие два позволяют задавать многострочные данные:

str3 = '''Многострочные
строки 1''';
 
str4 = """Многострочные
строки2""";
print(str1)
print(str2)
print(str3)
print(str4)

То есть, синтаксис из трех кавычек задает множественные строки. Причем, смотрите, если мы непосредственно в консоли напишем:

то при выводе после hello увидим символ \n, который и означает перевод строки. Функция print обрабатывая этот символ делает перевод строки:

Если в кавычках ничего не записано:

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

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

str1 = "сообщение"

и мы другой переменной присвоим первую:

то получим две ссылки на один и тот же объект (одну строку). То есть, копирование строки здесь не происходит!

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

Операторы и функции для строк

Первый оператор + – это соединение двух строк (или как еще говорят, конкатенация строк). Он используется так:

str1 = 'Hello'
str2 = "world!"
msg = str1+str2
print(msg)

Здесь сначала будут идти символы первой строки, а затем – второй. В результате у нас формируется новый объект, содержащий эти символы. Но у нас оба слова слились в одно. Как можно было бы добавить между ними пробел? Это можно сделать так:

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

dig = 5
msg = "число = "+dig
print(msg)

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

<p align=center>str(<аргумент>)
msg = "число = "+str(dig)

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

Далее, в Python довольно просто выполняется дублирование строки. Предположим у нас есть вот такая строка:

и мы хотим ее размножить n раз. Это можно сделать так:

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

нельзя, произойдет ошибка.

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

len(<строка>)

Например:

N = len(msg)
print(msg, N)

Затем, для проверки наличия в строке той или иной подстроки, используется оператор in:

<подстрока> in <строка>

Он возвращает True, если подстрока присутствует и False, если отсутствует. Например:

s = "abcdefg0123"
"abc" in s
'0' in s
'43' in s

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

<строка 1> == <строка 2>

Данный оператор возвращает True, если строки равны и False, если не равны. Пример:

"abc" == 'abc'
"ABC" == 'abc'

Обратите внимание, строка, записанная заглавными буквами – это в Python уже другая строка и оператор сравнения для них возвращает False.

Для сравнения неравенства строк используется оператор не равно:

<строка 1> != <строка 2>

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

Разумеется, эти операции сравнения обычно используются в условном операторе if или операторах циклов while и for, о которых мы уже с вами говорили. Например, можно записать такую программу:

psw = "pass"
in_psw = ""
while psw != in_psw:
   in_psw = input("Введите пароль: ")
print("Вход в систему разрешен")

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

Также строки можно сравнивать на больше и меньше:

<строка 1> < <строка 2>
<строка 1> > <строка 2>

Здесь используется лексикографический порядок при определении: какая строка больше, а какая меньше. Мы об этом подробно говорили, когда рассматривали условный оператор if.

Следующая функция

ord(<символ>)

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

ord("a")
ord('A')
ord('0')

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

Программирование в Python. Работа со строками — RUUD

Содержание статьи:

В повседневной жизни программисту нужно решать массу задач. Для этих целей идеально подходит язык Python («Пайтон» или «Питон», на русский манер). Резервное копирование, создание игры для Android или для Windows, чтение и сохранение писем из электронной почты – не самые сложные задачи для опытного программиста. А вот для начинающих изучать Python (работу со строками, списками, файлами) покажется сказкой, поскольку методы и функции каждого типа данных облегчают жизнь пользователю.

Что такое строковый тип данных?

Вам будет интересно:Запрос MySQL SELECT. Описание, применение и функции

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

В Python обучение предполагает изучение 2 разновидностей текста: обычные строки (последовательность байтов) и Unicode-string (перечень символов).

В Python скрипты позволяют использовать строковые литералы. Эти символы могут быть записаны с помощью апострофа, кавычек (одинарных или двойных), указанных символов, введенных трижды, к примеру, «»»applentree»»», где n выполняет роль Enter при наборе текста в обычном текстовом редакторе. Обратная косая черта (обратный слэш) внутри литералов получает особое значение. Она необходима для ввода специальных символов. Следует помнить, что обратный слэш не должен быть последним символом в программной строке, иначе компилятор выдаст ошибку.

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

Вам будет интересно:Как найти в Python остаток от деления?

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

Любой объект в «Питоне» можно привести к строковому типу данных посредством вызова встроенной функции str (). В Python имеется несколько классов. Чтобы перевести объект из одного типа данных в другой, можно воспользоваться функцией приведения, имя которой совпадает с именем разряда. Так, int переводит в целое число, str в строку, float в вещественный разряд.

Срезы в строках

Иначе они называются слайсами или slices. Срез позволяет извлечь из введенной строки символ, находящийся в указанном промежутке. Слайс невозможно использовать без индексации. Адресация начинается с 0. Если обращаться к строке с конца, то индексация начинается со знака -.

Строка ST

W

O

R

L

D

Индексация

ST[0]

ST[1]

ST[2]

ST[3]

ST[4]

Индексация

ST[-5]

ST[-4]

ST[-3]

ST[-2]

ST[-1]

Различают 3 формы срезов:

  • Извлечение одного символа из всей строки St[i], где St – текст, i – номер ячейки.
  • Получение отрывка текста, St[a:b], где St – текст, a и b – начало и конец промежутка. A включается в срез, параметр b нет. Если в промежутке не указать b, а поставить двоеточие, то программа вернет отрывок, взятый до конца строки. Если не проставлять параметр a, то слайс берет свое начало с 0 индекса до конечного пункта b.
  • Срез St[a:b:d] позволяет выбрать конкретный отрывок в промежутке с началом в a и концом в b с шагом d.

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

У пользователя есть возможность использовать в Python функции работы со строками:

  • Str(X) – перевод любого объекта в строковый тип данных.
  • ST1+ST2 – конкатенация (сложение строк).
  • ST*n – повторение ST строки n раз.
  • Min [ST] – возвращение минимального значения из кодовой таблицы.
  • Len () – определение длины текста.
  • Max [ST] – получение максимального значения из таблицы ASCII.
  • St1 in St2 – вхождение подстроки St1 в St2. Вернет True, если St1 присутствует в изначальном тексте.
  • St1 not in St2 – проверяет отсутствие St1 в St2 и возвращает True при верности утверждения.

Методы строкового типа данных

В Python работа со строками предполагает использование нескольких методов:

  • St.find и St.rfind – методы, необходимые для поиска нужного отрывка в введенном тексте. Их отличие в том, что этот процесс начнется с разных концов. Так, St.find ищет с начала, а St.rfind с конца. Методы возвращают индекс первого вхождения искомого отрывка. Можно указывать срезы для поиска в конкретном промежутке.
  • St.replace (a_old,b_new) необходим для замены всех вхождений подстроки в введенном тексте. Вместо a_old будет b_new. Если указать дополнительный параметр count (St.replace (a_old,b_new, count)), то замена будет происходить количество раз, не большее, чем count.
  • St.count – метод, необходимый для подсчета количества вхождения подстроки S в введенном тексте. Количество пересечений не входит в конечный результат. Можно указать промежуток, на котором будет происходить операция.
  • St.join необходим для объединения списка слов в строку.
  • St.split – метод, позволяющий превратить строку в список слов. В скобках в кавычках указывается разделитель. Чаще всего это пробел St.split(“ ”).
  • St.strip – удаление пробелов в начале и конце строки.
  • St.capitalize делает первый символ в тексте заглавным.
  • St.swapcase позволяет перевести регистр букв в противоположный.
  • St.upper дает возможность сделать все буквы заглавными в строке.
  • St.lower позволяет перевести введенный текст в нижний регистр. Все буквы станут строчными.

Форматная строка

В Python работа со строками приятна и тем, что пользователю предоставляется возможность отформатировать текст по указанному подобию. Т. е. программист задает условие, которому должен соответствовать введенный отрывок. Подобным образом можно выводить на экран таблицы без подключения специального модуля PTable. Называется этот прием форматная строка. К примеру, если ввести в IDLE print «%s is %d» % («one»,1), то результатом станет one is 1.

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

Форматный символ

Разъяснение

Вывод единичного символа.

%s

Строковое выражение.

%d

Указание десятичного целого числа.

%f

Вывод вещественного (дробного) десятичного числа.

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

Несколько задач с решениями

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

1. Дана строка. Получить новый текст, в котором происходит замена всех вхождений первого символа “$”, кроме него самого.

Алгоритм:

  • Написать функцию, в которой:
    • переменной char присваивается первый символ из строки;
    • length определяет длину строки;
    • str1 через метод replace заменяет char на символ “$”;
    • str1 записывает первый символ и получившееся выражения от предыдущей операции;
    • вернуть значение str1.
  • Вывести на экран результат вычисления функции.

2. Дана строка. Написать код, в котором к концу слова будет прибавляться “ing”, если длина слова >2. Если слово оканчивается на “ing”, то прибавить к строке “ly”. Если длина менее 2, оставить текст без изменений.

Алгоритм:

  • Написать функцию, в которой:
    • определяется длина текста;
    • проверяется условие: если длина >2 и если слово оканчивается на “ing”, то прибавить к такой строке “ly”, в противном случае добавить “ing”;
    • вернуть значение полученной переменной.
  • Вывести на экран результаты функции с несколькими строками.

Для закрепления результата написания кода в «Питоне» необходимо решить еще несколько задач со строками.

Источник

Функция Python String join () — AskPython

В этой статье мы рассмотрим функцию Python String join () . Как следует из названия, он используется для объединения строк и работает с данными строкового типа.


Понимание метода Python string join ()

Python String имеет различные встроенные функции для работы со строковым типом данных.

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

Функция join () возвращает строку, в которой объединяет элементы итерации с разделительной строкой , переданной в качестве аргумента функции.

Синтаксис:

separator-string.join (повторяемый)
 

Пример 1:

inp_str = 'JournalDev'
insert_str = '*'
res = insert_str.присоединиться (inp_str)
печать (разрешение)
 

Выход:

J * o * u * r * n * a * l * D * e * v
 

Пример 2:

inp_str = 'ПИТОН'
insert_str = '#!'
res = insert_str.join (inp_str)
печать (разрешение)
 

Выход:

П #! У #! Т #! Ч #! О #! Н
 

Привет, ребята! Самым важным моментом, который следует принять во внимание, является то, что функция join () работает только с входными значениями строкового типа . Если мы вводим любой из параметров нестрокового типа , он вызывает исключение TypeError .

Пример:

inp_str = 200 # ввод нестрокового типа
insert_str = 'S'
res = insert_str.join (inp_str)
печать (разрешение)
 

В приведенном выше примере строке разделителя, то есть insert_str, было присвоено целочисленное значение. Таким образом, это вызовет исключение TypeError.

Выход:

-------------------------------------------------- -------------------------
TypeError Traceback (последний вызов последним)
 в <модуль>
      1 inp_str = 200 # ввод нестрокового типа
      2 insert_str = 'S'
----> 3 res = insert_str.присоединиться (inp_str)
      4 отпечатка (разрешение)

TypeError: может присоединяться только к итерируемому
 

Метод Python string join () со списком в качестве итеративного :

Синтаксис:

строка-разделитель.join (список)
 

Пример:

inp_lst = ['10', '20', '30', '40']
sep = '@@'
res = sep.join (inp_lst)
печать (разрешение)
 

В приведенном выше примере разделительная строка «@@» присоединяется к каждому элементу входного списка i.е. inp_lst.

Выход:

10 @@ 20 @@ 30 @@ 40
 

Python метод join () с набором итерация :

Синтаксис:

строка-разделитель.join (набор)
 

Пример:

inp_set = ('10', '20', '30', '40').
sep = '**'
sep1 = '<'
res = sep.join (inp_set)
печать (разрешение)
res1 = sep1.join (inp_set)
печать (res1)
 

В приведенном выше примере разделительная строка «**» и «<» присоединяется к каждому элементу входного набора.

Выход:

10 ** 20 ** 30 ** 40
10 <20 <30 <40
 

Python метод join () со словарем в качестве итерации:

Метод Python string join () также может быть применен к словарю как итеративный.

Но важно отметить, что метод join () работает только с ключами структуры данных словаря , а не со значениями, связанными с ключами.

Синтаксис:

строка-разделитель.join (dict)
 

Пример 1:

inp_dict = {'Python': '1', 'Java': '2', 'C ++': '3'}
sep = '##'
res = sep.join (inp_dict)
печать (разрешение)
 

Как видно из приведенного выше примера, метод join () рассматривает только ключи dict для манипуляции. Он полностью игнорирует значения dict.

Выход:

Python ## Java ## C ++
 

Пример 2:

inp_dict = {'Python': 1, 'Java': 2, 'C ++': 3}
sep = '##'
res = sep.присоединиться (inp_dict)
печать (разрешение)
 

В приведенном выше примере значения в слове не являются строковыми. Тем не менее, это не вызовет ошибок при выполнении кода, потому что метод join () имеет дело только с ключами словаря.

Выход:

Python ## Java ## C ++
 

Пример 3:

inp_dict = {1: 'Python', 2: 'Java', 3: 'C ++'}
sep = '##'
res = sep.join (inp_dict)
печать (разрешение)
 

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

Выход:

TypeError Traceback (последний вызов последним)
 в <модуль>
      1 inp_dict = {1: 'Python', 2: 'Java', 3: 'C ++'}
      2 сен = '##'
----> 3 res = sep.join (inp_dict)
      4 отпечатка (разрешение)

TypeError: элемент последовательности 0: ожидаемый экземпляр str, найдено int

 

Python numpy.join () метод

Модуль

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

numpy.core.defchararray.join (sep-string, inp-arr) используется для соединения элементов массива с переданной строкой разделителя в качестве аргумента.

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

Синтаксис:

numpy.core.defchararray.join (строка-разделитель, массив)
 

Пример 1:

импортировать numpy как np
inp_arr = np.array (["Python", "Java", "Ruby", "Kotlin"])
sep = np.array ("**")
res = np.core.defchararray.join (sep, inp_arr)
печать (разрешение)

 

В приведенном выше примере мы сгенерировали массив из переданных элементов списка с помощью метода numpy.array () . Кроме того, с помощью функции join () он присоединяет строку «**» к каждому элементу массива.

Выход:

['P ** y ** t ** h ** o ** n' J ** a ** v ** a '' R ** u ** b ** y '' K ** o ** t ** l ** i ** n ']
 

Пример 2:

импортировать numpy как np
inp_arr = np.array (["Python", "Java", "Ruby", "Kotlin"])
sep = np.array (["**", "++", "&&", "$$"])
res = np.core.defchararray.join (sep, inp_arr)
печать (разрешение)

 

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

Выход:

['P ** y ** t ** h ** o ** n' 'J ++ a ++ v ++ a' 'R && u && b && y' 'K $$ o $$ t $$ l $$ i $$ n ']
 

Python Pandas str.join () метод

Модуль

Python Pandas имеет встроенный метод pandas.str.join () для соединения элементов набора данных с предоставленным разделителем.

Метод pandas.str.join () работает с конкретными значениями столбцов (данных) набора данных или входной серии и возвращает серию с объединенными элементами данных с разделительной строкой или разделителем.

Синтаксис:

Series.str.join (разделитель или строка-разделитель)
 

Ввод.csv файл: Book1.csv

Входной файл CSV-Book1

Пример:

импортные панды
info = pandas.read_csv ("C: \\ Book1.csv")
info ["Name"] = info ["Name"]. str.join ("||")
печать (информация)
 

В приведенном выше примере мы использовали метод pandas.read_csv () для чтения содержимого набора данных. Далее мы присоединяем разделительную строку, т.е. «||» к значениям данных столбца «Имя» входного набора данных.

Выход:

           Назовите возраст
0 Дж || i || м 21
1 Дж || e || n || n || y 22
2 Б || г || а || п 24
3 S || h || a || w || n 12
4 R || i || t || i || k 26
5 R || o || s || y 24
6 D || а || n || n || y 25
7 D || a || i || s || y 15
8 Т || o || м 27
 

Сводка

  • Метод join () используется для соединения элементов или итераций строкового типа с элементом разделителя строк .
  • Аргументы: повторяющиеся элементы и разделитель должны быть обязательно строкового типа .
  • Более того, метод Python join () также может применяться к итерациям, таким как набор, список, dict и т. Д.
  • Метод join () вызывает исключение TypeError , если разделитель или итерация ввода содержит элементы не -стринговый тип.

Заключение

Таким образом, в этой статье мы поняли работу метода Python String join () с различными итерациями, такими как set, list, tuple, dict и т. Д.


Список литературы

Python Strings

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

Пример:

  ch =' HelloPython '

str1 = "String Chapter"  

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

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

Программа показывает использование строк и их отображение на экране.

Пример:

  ch = 'Hello Python'

str1 = "Глава строки"

print ("Первое значение:", ch)

print ("Второе значение:", str1)  

Вывод:

 Первое значение: Hello Python
Второе значение: String Chapter 

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

Пример:

  ch = "Hello Python"

str1 = "Глава строки"

print ("Первая подстрока:", ch [0])

print ("Набор подстроки:", str1 [2: 5])  

Вывод:

 Первая подстрока: H
Набор подстроки: rin
 

Обновление строкового значения или переменной

Переназначение существующей строковой переменной в Python более просто.Мы должны использовать оператор + вместе с расположением подстроки. Покажем это в качестве примера:

Пример:

  ch = "Hello Python"

print ("ОБНОВЛЕННАЯ СТРОКА БУДЕТ:", ch [: 8] + "Python")  

Вывод:

 ОБНОВЛЕННАЯ СТРОКА БУДЕТ: Hello PyPython
 

Escape-символы

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

  • \ a : alert
  • \ b : backspace
  • \ cx : Control X
  • \ e : escape
  • \ f : Подача формы
  • \ n : новая строка или следующая строка
  • \ r : возврат каретки
  • \ s : spa

Преобразовать список в строку в Python с помощью join () / reduce () / map ( ) - thispointer.com

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

Преобразование списка в строку в Python с помощью join () в Python

В строковом классе Python предусмотрена функция join (), т.е.

 string.join (итерация) 
Функция

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

Давайте воспользуемся этой функцией join () для преобразования списка в строку в Python.

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

 def convert_list_to_string (org_list, seperator = ''):
    "" "Преобразовать список в строку, объединив все элементы в списке с заданным разделителем.Возвращает составную строку "" "
    вернуть seperator.join (org_list)
 

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

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

Предположим, у нас есть список строк,

 list_of_words = ["Это", "есть", "a", "образец", "программа"] 

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

 def convert_list_to_string (org_list, seperator = ''):
    "" "Преобразовать список в строку, объединив все элементы в списке с заданным разделителем.Возвращает составную строку "" "
    вернуть seperator.join (org_list)

# Преобразовать список строк в строку
full_str = convert_list_to_string (список_слов)

печать (full_str)
 

Выход:

 Это пример программы 

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

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

 def convert_list_to_string (org_list, seperator = ''):
    "" "Преобразовать список в строку, объединив все элементы в списке с заданным разделителем.Возвращает составную строку "" "
    вернуть seperator.join (org_list)

# Присоединяем все строки в списке
full_str = convert_list_to_string (список_слов, ',')

печать (full_str)
 

Выход:

 Это пример программы 

В этом примере, вызывая функцию convert_list_to_string (), мы передали запятую «,» в качестве разделителя / разделителя, поэтому он объединил все элементы в списке, используя запятую в качестве разделителя.

Преобразовать список в строку с настраиваемым разделителем в Python

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

 def convert_list_to_string (org_list, seperator = ''):
    "" "Преобразовать список в строку, объединив все элементы в списке с заданным разделителем.
        Возвращает составную строку "" "
    вернуть seperator.join (org_list)

# Присоединяем все строки в списке
full_str = convert_list_to_string (список_слов, '---')
печать (full_str)
 

Выход:

 Это --- пример --- программа 

В этом примере при вызове функции convert_list_to_string () мы передали запятую «-» в качестве разделителя / разделителя, поэтому она объединила все элементы в списке, используя «—-» в качестве разделителя.

Преобразование списка целых чисел в строку в Python с помощью join () в Python

Предположим, у нас есть список целых чисел,

 list_of_num = [1, 2, 3, 4, 5]
 

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

 1 2 3 4 5 

Мы можем использовать функцию join (), но нам нужно сначала преобразовать список целых чисел в список строк, а затем мы можем объединить все элементы в этом списке, чтобы создать строку с разделителем.Например,

 list_of_num = [1, 2, 3, 4, 5]

# Скрытый список целых чисел в строку
full_str = '' .join ([str (elem) для элемента в list_of_num])

печать (full_str) 

Выход:

 1 2 3 4 5 

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

Преобразование списка элементов разного типа в строку с помощью join () в Python

Предположим, у нас есть список, который содержит различные типы элементов, такие как int, float, strings и т. Д.,

 mix_list = ["This", "is", "a", "sample", 44, 55, 66, "program"] 

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

 Это образец 44 55 66 программа 

Мы можем использовать функцию join (), но нам нужно сначала преобразовать список элементов другого типа в список строк. Для этого нам нужно вызвать str () для каждого элемента списка, чтобы преобразовать его в строку. Затем мы можем объединить все элементы в новом списке строк, чтобы создать строку.

Например,

 mix_list = ["This", "is", "a", "sample", 44, 55, 66, "program"]

# Скрыть список разных типов элементов в строку
full_str = ''.join ([str (elem) для элемента в mix_list])

печать (full_str)
 

Выход:

 Это образец 44 55 66 программа 

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

Преобразовать список в строку с помощью reduce () в Python

 уменьшить (функция, последовательность [, начальная]) 
Модуль

functools в Python предоставляет функцию reduce (), которая принимает повторяемую последовательность в качестве аргумента и функцию в качестве аргумента. Эта функция генерирует одно значение из всех элементов в заданной повторяемой последовательности.Для генерации значения он передаст первые два значения заданному аргументу функции, а затем продолжит вызывать ту же функцию с результатом и следующим аргументом. Когда он потребляет все элементы по порядку, возвращается окончательное значение результата.

Давайте используем это, чтобы преобразовать список в строку,

 list_of_words = ["Это", "есть", "a", "образец", "программа"]

разделитель = ''
final_str = functools.reduce (лямбда a, b: a + разделитель + b, список_слов)

печать (final_str)
 

Выход:

 Это пример программы 

Здесь мы передали два аргумента функции reduce (),

  • Лямбда-функция, которая принимает 2 аргумента и соединяет эти аргументы с разделителем между ними.
  • Список строк

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

Преобразование списка целых чисел в строку с помощью reduce () в Python

 list_of_num = [1, 2, 3, 4, 5]

разделитель = ''
final_str = functools.reduce (лямбда a, b: str (a) + delimiter + str (b), list_of_num)

печать (final_str)
 

Выход:

 1 2 3 4 5 

Здесь мы передали два аргумента функции reduce (),

  • Лямбда-функция, принимающая 2 аргумента.Затем преобразует оба аргумента в строку и объединяет эти аргументы с разделителем между ними.
  • Список строк

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

Преобразование списка в строку с помощью map () в Python

Функция

map () в python принимает 2 аргумента, т.е. функцию и повторяемую последовательность. Затем вызывает данную функцию для каждого элемента в последовательности и возвращает Iterator для перебора объектов результата.

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

 mix_list = ["This", "is", "a", "sample", 44, 55, 66, "program"]

разделитель = ''

# Преобразовать список элементов в строковое значение
final_str = delimiter.join (карта (str, mix_list))
печать (final_str)
 

Выход:

 Это образец 44 55 66 программа 

Здесь мы передали два аргумента функции map (),

  • Функция str (), которая преобразует данный объект в строковое значение.
    Список различных типов элементов.
  • Он перебирал все значения в списке и вызывал функцию str () для каждого элемента. Все строковые значения были возвращены через итератор. Затем, используя функцию join (),

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

Полный пример выглядит следующим образом:

 import functools


def convert_list_to_string (org_list, seperator = ''):
    "" "Преобразовать список в строку, объединив все элементы в списке с заданным разделителем.Возвращает составную строку "" "
    вернуть seperator.join (org_list)


def main ():
    print ('*** Преобразовать список в строку с помощью join () в python ***')

    print ('*** Преобразовать список в строку с пробелом в качестве разделителя ***')

    list_of_words = ["Это", "это", "а", "образец", "программа"]

    # Преобразовать список строк в строку
    full_str = convert_list_to_string (список_слов)

    печать (full_str)

    print ('*** Преобразовать список в строку с запятой в качестве разделителя ***')

    # Присоединяем все строки в списке
    full_str = convert_list_to_string (список_слов, ',')

    print ('*** Преобразовать список в строку с настраиваемым разделителем ***')

    # Присоединяем все строки в списке
    full_str = convert_list_to_string (список_слов, '---')

    печать (full_str)

    print ('*** Преобразовать список в int в строку ***')

    list_of_num = [1, 2, 3, 4, 5]

    # Скрытый список целых чисел в строку
    full_str = ''.присоединиться ([str (elem) для элемента в list_of_num])

    печать (full_str)

    print ('*** Преобразовать список элементов разного типа в строку ***')

    mix_list = ["Это", "есть", "а", "образец", 44, 55, 66, "программа"]

    # Скрыть список разных типов элементов в строку
    full_str = '' .join ([str (elem) для элемента в mix_list])

    печать (full_str)

    print ('*** Преобразовать список в строку с помощью reduce () ***')

    list_of_words = ["Это", "это", "а", "образец", "программа"]

    разделитель = ''
    final_str = functools.уменьшить (лямбда a, b: a + разделитель + b, список_слов)

    печать (final_str)

    print ('*** Преобразовать список целых чисел в строку с помощью reduce () ***')

    list_of_num = [1, 2, 3, 4, 5]

    разделитель = ''
    final_str = functools.reduce (лямбда a, b: str (a) + delimiter + str (b), list_of_num)

    печать (final_str)

    print ('*** Преобразовать список в строку с помощью map () и join () ***')

    mix_list = ["Это", "есть", "а", "образец", 44, 55, 66, "программа"]

    разделитель = ''

    # Преобразовать список элементов в строковое значение
    final_str = разделитель.присоединиться (карта (str, mix_list))
    печать (final_str)

если __name__ == '__main__':
   основной () 

Выход:

 *** Преобразование списка в строку с помощью join () в Python ***
*** Преобразовать список в строку с пробелом в качестве разделителя ***
Это пример программы
*** Преобразовать список в строку с запятой в качестве разделителя ***
*** Преобразование списка в строку с настраиваемым разделителем ***
Это --- --- --- пример --- программа
*** Преобразовать список в int в строку ***
1 2 3 4 5
*** Преобразование списка элементов разного типа в строку ***
Это пример программы 44 55 66
*** Преобразование списка в строку с помощью reduce () ***
Это пример программы
*** Преобразуйте список целых чисел в строку с помощью reduce () ***
1 2 3 4 5
*** Преобразование списка в строку с помощью map () и join () ***
Это образец 44 55 66 программы 

строк Python

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

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

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

a = "Привет" b = "Привет!" c = "742 Вечнозеленая терраса" d = "1234" e = "'Какова длина веревки?' он спросил" f = "'! $ * # @ you!' она ответила "

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

Результат

  Привет
Привет всем!
742 Evergreen Terrace
1234
«Какова длина веревки?» он спросил
'! $ * # @ you!' она ответила  

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

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

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

Результат

  3  

Числа в строках

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

а = 1 a = "1"

В первой строке значение 1 представляет собой число.Во второй строке это строка.

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

Так делаем это:

печать (1 + 2) print ("1" + "2")

Результатов в этом:

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

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

Python включает функции, которые позволяют определять, состоит ли строка исключительно из чисел. В частности, он включает в себя функции isnumeric () , isdigit () и isdecimal () . Это позволяет вам уточнить тип числа, содержащегося в строке.

Эти функции возвращают true , если все символы в строке совпадают (и есть хотя бы один символ).В противном случае они возвращают false .

Вот пример использования isnumeric () :

a = "pic123" b = "21344" печать (a.isnumeric ()) print (b.isnumeric ())

Результат

  Ложь
Правда  

Функция isnumeric () является широкой и включает все результаты, которые будут возвращены функциями isdigit () и isdecimal () .

Цитаты в строках

Если вы сделаете это, вы получите сообщение об ошибке:

e = "Еще раз он спросил:" Какова длина веревки? ""

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

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

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

Итак, мы можем изменить приведенный выше код на этот:

e = "Он снова спросил: \" Какова длина веревки? \ "" print (e)

Результат

  Он снова спросил: "Какова длина веревки?"  

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

e = "Он снова спросил:" Какова длина веревки? "" # ИЛИ ЖЕ e = 'Он снова спросил: «Какова длина веревки?» »

Строки, состоящие из нескольких строк

Есть несколько разных способов сделать строку из нескольких строк.

Последовательность побега

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

msg = "ВНИМАНИЕ! \ rДля тех, кто собирается радоваться, мы приветствуем вас!" print (msg)

Результат

  ВНИМАНИЕ!
Для тех, кто собирается радоваться, мы приветствуем вас!  

Тройные цитаты

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

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

msg = "" "Эта строка пролеты несколько строк "" " печать (сообщение)

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

msg = '' 'Эта строка пролеты несколько строк '' ' печать (сообщение)

И результат такой:

Результат

  Эта строка
пролеты
несколько строк  

Последовательности побега

Вот таблица управляющих последовательностей, доступных в Python:

Escape Sequence Описание
\ новая строка Обратная косая черта и новая строка игнорируются
\ Обратная косая черта ( \ )
\ ' Одинарная кавычка ( ')
\ " Двойная кавычка ( ")
\ а Звонок ASCII (BEL)
\ b ASCII Backspace (BS)
\ f ASCII Formfeed (FF)
\ n ASCII перевод строки (LF)
\ r ASCII возврат каретки (CR)
\ т Горизонтальная вкладка ASCII (TAB)
\ v Вертикальная табуляция ASCII (VT)
\ ooo Знак с восьмеричным числом ооо
\ xhh Символ с шестнадцатеричным значением hh

Некоторые escape-последовательности распознаются только в строковых литералах.Это:

Escape Sequence Описание
\ N {name} Символ с именем имя в базе данных Unicode
\ uxxxx Символ с 16-битным шестнадцатеричным значением xxxx . Требуется ровно четыре шестнадцатеричных цифры.
\ Uxxxxxxxx Символ с 32-битным шестнадцатеричным значением xxxxxxxx .Требуется ровно восемь шестнадцатеричных цифр.

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

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

planet = "Юпитер" print (planet [2])

Результат

  п.  

Причина, по которой была возвращена буква p , заключается в том, что мы указали 2 в качестве индекса внутри квадратных скобок. Python использует индексирование с нуля (т.е.е. он начинает отсчет с нуля - например, 0, 1, 2, 3 и т. д.), поэтому в результате печатается третья буква.

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

planet = "Юпитер" print (планета [2: 5])

Результат

  приямок  

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

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

Работает так:

print ("Здравствуйте,% s, вы набрали% i из% i"% ("Homer", 3, 100))

Результат

  Привет, Гомер, вы набрали 3 балла из 100  

Итак, мы использовали % s там, где мы хотели вставить строку, и % i для целого числа. Значения предоставляются после % после конца строки.

Python String Metotları

Split Metodu

Split metodu, karakter dizisinde belirtilen bir karaktere göre parçalama işlemi yapar.

Орнек

message = 'Привет, здесь.'
message = message.split (',') # ['Привет', 'Вот'] 

Karakter dizisini ',' karakterinden parçalara ayırır ve bize bir liste gönderir.

Split metoduna bir Paratre göndermediğimizde ise, boşluk karakterinden parçalama yapılır.

Орнек

message = 'Привет, здесь.'
message = message.split () # ['Привет,', 'Вот.'] 

Верхний Методу

Верхний метод, karakterleri büyük harfe çevirir.

Орнек

message = 'Привет.'
message = message.upper () # ЗДЕСЬ ПРИВЕТ. 

Нижний Методу

Lower metodu, karakterleri büyük harfe çevirir.

Орнек

message = 'ПРИВЕТ ЗДЕСЬ.'
message = message.upper () # Здравствуйте. 

** название () метод, karakter dizisindeki her kelimenin baş harfini büyük harfe çevirir.

** capitalize (), karakter dizisindeki sadece ilk kelimenin baş harfini büyük harfe çevirir.

Полоса Методу

Strip metodu, karakter dizisinin baş ve sondaki boşluk karakterlerini siler.

Орнек

username = "sadikturan"
x = имя пользователя.полоса ()
print ("мое имя пользователя + x") # мое имя пользователя - sadikturan 

Eğer strip () metodunun belirttiğimiz karakterleri silmesini istersek bu karakteri parameter olarak göndermemiz gerekir.

Орнек

username = ",,,, ... !! sadikturan ***"
x = имя пользователя.strip (',.! *')
print ("мое имя пользователя + x") # мое имя пользователя - sadikturan 

Заменить Metodu

Заменить metodu karakter güncellemesi için kullanılır.

Орнек

message = 'Меня зовут Садик Туран'
message = message.replace ('Sadık', 'ınar') # Меня зовут ınar Turan 

replace () metotlarını ard arda kullanabiliriz.

Орнек

url = url.replace ('', '-')
         .replace ('@', '')
         .replace ('ö', 'о')
         .replace ('ü', 'и')
         .replace ('ş,' s ')
         .replace ('ü', 'и') 

şeklinde türkçe karakterleri, boşluk karakterlerini ve '@' işaretini url içinde güncelleyebiliriz.

Найди Методу

Найти metodu verilen string ifade içinde arama yapar ve bulduğu ilk indeks numarasını döndürür. Eğer bulamazsa exception döndürür.

Орнек

txt = "Меня зовут Садик Туран."
x = txt.find ("имя")
print (x) # x = 3 

имя строка içerisinde 3.indeks numarasından itibaren başladığından dolayı 3 değeri yazdırılır.

Индекс Методу

index metodu verilen string ifade içinde arama yapar ve bulduğu ilk indeks numarasını döndürür.Eğer bulamazsa найти metodundan farklı olarak geriye -1 değerini döndürür.

Орнек

txt = "Меня зовут Садик Туран."
x = txt.index ("имя")
print (x) # x = 3 

Eğer ki string içinde olmayan bir ifadeyi aratırsak geriye -1 döner.

Орнек

txt = "Меня зовут Садик Туран."
x = txt.index ("старый")
print (x) # x = -1 

старый, строка içinde bulunmadığından dolayı -1 döner.

** Ayrıca index ve find metodu için bir arama kapsamı belirtebiliriz.

index ("aranılacak ifade", "başlangıç ​​indeksi", "bitiş indeksi") 

Орнек

txt = "Меня зовут Садик Туран."
x = txt.index ("имя", 0,10)
print (x) # x = 3 

0 ile 10. indeks arasında bir arama yapılır.

Струна Метот Уйгуламалары

website = "http: // www.sadikturan.com "
course = "Python Kursu: Baştan Sona Python Programlama Rehberiniz (40 саат)" 

1- «Hello World» karakter dizisinin baş ve sondaki boşluk karakterlerini silin.

result = 'Hello World' .strip () # baş ve sondaki boşluk karakterleri silinir.
result = 'Hello World' .lstrip () # baştaki boşluk karakterleri silinir.
result = 'Hello World' .rstrip () # sondaki boşluk karakterleri silinir.
результат = сайт.lstrip ('/: pth') # baştan itibaren '/: pth' karakteri silinir. результат "www.sadikturan.com" değerini alır. 

2- «www.sadikturan.com» içindeki sadikturan bilgisi haricindeki her karakteri silin.

result = 'www.sadikturan.com'.strip (' w.moc ') 

3- «курс» karakter dizisinin tüm karakterlerini küçük harf yapın.

result = course.lower () # küçük harfe çevrilir.
result = course.upper () # büyük harfe çevrilir.result = course.title () # her kelimenin baş harfe büyük harfe çevrilir. 

4- «сайт» içinde kaç tane a karakteri vardır? (количество ('а'))

result = website.count ('a') # a karakteri sayılır.
result = website.count ('www') # www karakterleri sayılır.
result = website.count ('www', 0,10) # 0 ile 10. indeks arasında www ifadesi sayılır. 

5- 'веб-сайт' «www» ile başlayıp com ile bitiyor mu?

результат = сайт.начинается с ('www') # website www ile başlıyor mu? Ложь
result = website.startswith ('http') # website http ile başlıyor mu? Правда
result = website.endswith ('com') # website com ile bitiyor mu? Правда 

6- 'сайт' içinde 'com' ifadesi var mı?

result = website.find ('com') # website içerisinde 'com' ifadesini arar ve geriye 22 döner.
result = website.find ('com', 0,10) # 0 ile 10 arasında com ifadesini bulamaz ve exception döndürür.result = course.find ('Python') # 0.indeksten itibaren bulduğu ilk Python için 0 değeri döner.
result = course.rfind ('Python') # Aramaya sağdan başlayacağından dolayı 2. Python 'i 26. indexte bulur.
result = website.index ('com') # website içerisinde 'com' ifadesini arar ve geriye 22 döner.
result = website.rindex ('com') # website içerisinde 'com' ifadesini arar ve geriye 22 döner.
result = website.rindex ('comm') # comm bulunamadığından "ValueError: подстрока не найдена" hatası gelir.

7- 'курс' içindeki karakterlerin hepsi alfabetik mi? (исальфа, исцифра)

result = course.isalpha () # tüm karakterler alfabetik mi diye sorar ve False gelir.
result = 'Hello'.isalpha () # tüm karakterler alfabetik olduğundan True gelir.
result = course.isdigit () # tüm karakterler rakam mı diye sorar ve False gelir.
result = '123'.isdigit () # tüm karakterler rakam mı diye sorar ve True gelir. 

8- «Содержание» ifadesini satırda 50 karakter içine yerleştirip sağ ve soluna * ekleyiniz.

result = 'Contents'.center (50,' * ') # **** Contents **** şeklinde toplam 50 karakter olur.
result = 'Contents'.ljust (50,' * ') # Contents ********* şeklinde toplam 50 karakter olur.
result = 'Contents'.rjust (50,' * ') # ********* Contents şeklinde toplam 50 karakter olur. 

9- 'курс' karakter dizisindeki tüm boşluk karakterlerini '-' ile değiştirin.

result = course.replace ('', '-') # tüm boşluk karakterleri '-' ile değiştirilir.result = course.replace ('', '-', 5) # ilk 5 boşluk karakterleri '-' ile değiştirilir.
result = course.replace ('', '') # tüm boşluk karakteri silinir. 

10- 'Hello World' karakter dizisinin 'World' ifadesini 'There' olarak değiştirin

result = 'Hello World'.replace (' Мир ',' Там ') 

11- «курс» karakter dizisini boşluk karakterlerinden ayırın.

result = course.split ('') # ['Python', 'Kursu:', 'Baştan', 'Sona', 'Python', 'Programlama', 'Rehberiniz', '(40', 'saat)']
result = result [2] # 'Baştan'
result = result [5] # 'Programlama'
 

разделить метод иле строки ifadeyi ее boşluk karakterinden ayırıp bir listeye çevirmiş oluruz ве ее bir liste elemanına indeks numarası ile ulaşabiliriz.

.
Оставить комментарий

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

Ваш адрес email не будет опубликован.