MyTetra Share
Делитесь знаниями!
Обработка строк в Python
Время создания: 29.07.2019 23:51
Текстовые метки: Python, python-scripts.com,
Раздел: !Закладки - Python - python-scripts.com
Запись: xintrea/mytetra_db_adgaver_new/master/base/1516452409bjcl0iutes/text.html на raw.githubusercontent.com

python-scripts.com

автор

16-22 минуты


В Python существуют несколько видов данных. Основные типы данных, с которыми вы столкнетесь – это string, ingteger, float, list, dict и tuple. В данной статье мы рассмотрим тип данных string (строка). Вы удивитесь тому, сколько всего можно делать со строками в Python. Также существует модуль string, который можно импортировать для получения доступа к еще большим возможностям, но мы рассмотрим его в другой статье. Вместо этого, мы пройдемся по следующим разделам:

  • Как создавать строки
  • Конкатенация строк
  • Методы строк
  • Замена строк

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

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


my_string = "Добро пожаловать в Python!"

another_string = 'Я новый текст тут...'

a_long_string = '''А это у нас

новая строка

в троичных скобках'''

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


my_string = "I'm a Python programmer!"

otherString = 'Слово "Python" обычно подразумевает змею'

tripleString = """В такой "строке" мы можем 'использовать' все."""

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


my_number = 123

my_string = str(my_number)

Если вы впишете данный код в ваш интерпретатор, вы увидите, что вы изменили значение интегратора на строку и присвоили ее переменной my_string. Это называется кастинг, или конвертирование. Вы можете конвертировать некоторые типы данных в другие, например числа в строки. Но вы также заметите, что вы не всегда можете делать обратное, например, конвертировать строку вроде ‘ABC’ в целое число. Если вы сделаете это, то получите ошибку вроде той, что указана в этом примере:


int('ABC')

Traceback (most recent call last):

    File "<string>", line 1, in <fragment>

ValueError: invalid literal for int() with base 10: 'ABC'

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

То все должно работать. Обратите внимание на то, что строка – это один из неизменных типов Python. Это значит, что вы не можете менять содержимое строки после ее создания. Давайте попробуем сделать это и посмотрим, что получится:


my_string = "abc"

my_string[0] = "d"

Traceback (most recent call last):

    File "<string>", line 1, in <fragment>

TypeError: 'str' object does not support item assignment

Здесь мы пытаемся изменить первую букву с «а» на «d«, в итоге это привело к ошибке TypeError, которая не дает нам сделать это. Теперь вы можете подумать, что присвоение новой строке то же значение и есть изменение строки. Давайте взглянем, правда ли это:


my_string = "abc"

a = id(my_string)

print(a) # 19397208

my_string = "def"

b = id(my_string)

print(b) # 25558288

my_string = my_string + "ghi"

c = id(my_string)

print(c) # 31345312

Проверив id объекта, мы можем определить, что когда мы присваиваем новое значение переменной, то это меняет тождество. Обратите внимание, что в версии Python, начиная с 2.0, строки могут содержать только символы ASCII. Если вам нужен Unicode, тогда вы должны вписывать u перед вашей строкой. Пример:


# -*- coding: utf-8 -*-

my_unicode_string = u"Это юникод!"

В Python, начиная с версии 3, все строки являются юникодом.

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

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


# -*- coding: utf-8 -*-

string_one = "Собака съела "

string_two = "мою книгу!"

string_three = string_one + string_two

print(string_three) # Собака съела мою книгу!

Оператор + конкатенирует две строки в одну

Методы строк

Строка является объектом в Python. Фактически, все, что есть в Python – является объектом. Если вы хотите узнать больше об Объектно-ориентированном программирование, мы рассмотрим это в другой статье «Классы в Python«. В данный момент достаточно знать, что строки содержат собственные встроенные методы. Например, допустим, у вас есть следующая строка:


my_string = "This is a string!"

Теперь вам нужно сделать так, чтобы вся эта строка была в верхнем регистре. Чтобы сделать это, все, что вам нужно, это вызвать метод upper(), вот так:

Если вы открыли ваш интерпретатор, вы также можете сделать то же самое:


"This is a string!".upper()

Существует великое множество других методов строк. Например, если вам нужно, что бы все было в нижнем регистре, вам нужно использовать метод lower(). Если вы хотите удалить все начальные и конечные пробелы, вам понадобится метод strip(). Для получения списка всех методов строк, впишите следующую команду в ваш интерпретатор:

Вы увидите что-то на подобие этого:


[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__doc__’, ‘__eq__’, ‘__format__’,

‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__getslice__’, ‘__gt__’,

‘__hash__’, ‘__init__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’,

‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__-

setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_formatter_field_name_split’,

‘_formatter_parser’, ‘capitalize’, ‘center’, ‘count’, ‘decode’, ‘encode’, ‘endswith’, ‘expandtabs’,

‘find’, ‘format’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isdigit’, ‘islower’, ‘isspace’,

‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’,

‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’,

‘title’, ‘translate’, ‘upper’, ‘zfill’]

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


help(my_string.capitalize)

Вы получите следующую информацию:


Help on built-in function capitalize:

capitalize(...)

    S.capitalize() -> string

Выдача копии строки S только с заглавной буквой.

Вы только что узнали кое-что о разделе, под названием интроспекция. Python может исследовать все свои объекты, что делает его очень легким в использовании. В основном, интроспекция позволяет вам спрашивать Python о нём. Вам моет быть интересно, как сказать о том, какой тип переменной был использован (другими словами int или string). Вы можете спросить об этом у Python!


type(my_string) # <type 'str'>

Как вы видите, тип переменной my_string является str!

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

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


my_string = "I like Python!"

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


print( my_string[0:1] ) # I

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


0 1 2 3 4 5 6 7 8 9 10 11 12 13 - I l i k e P y t h o n !

Таким образом, у нас есть строка длиной в 14 символов, начиная с нуля и до тринадцати. Давайте приведем несколько примеров, чтобы понять это лучше.


my_string[:1] # 'I'

my_string[0:12] # 'I like Pytho'

my_string[0:13] # 'I like Python'

my_string[0:14] # 'I like Python!'

my_string[0:-5] # 'I like Py'

my_string[:] # 'I like Python!'

my_string[2:] # 'like Python!'

Как видно в данных примерах, мы можем назначить срез, лишь указав его начало (другими словами, my_string[2:]), конец среза (my_string[:1]), или оба (my_string[0:13]). Мы можем даже использовать отрицательные значения, которые начинаются с конца строки. Так что в примере, где мы указали my_string[0:-5], начало ведется с нуля и заканчивается 5 символами, перед концом строки. Вы можете задаться вопросом «Зачем мне это и где это можно применить?». Лично я использовал это для разбора записей с фиксированной шириной в файлах, или ситуативно для парсинга сложных названий файлов, с очень специфическими наименованиями. Также я использовал это для парсинга значений в бинарных файлах. Любая работа, которая включает в себя обработку текстовых файлов, может быть намного проще, если вы понимаете, как работает нарезка и как эффективно использовать данный инструмент. Вы также можете получить доступ к отдельным символам в строке с помощью индексации. Например:

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

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

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


# -*- coding: utf-8 -*-

my_string = "Я люблю %s" % "Python"

print(my_string) # Я люблю Python

var = "яблоки"

newString = "Я ем %s" % var

print(newString) # Я ем яблоки

another_string = "Я люблю %s и %s" % ("Python", var)

print(another_string) # Я люблю Python и яблоки

Как вы могли догадаться, % — это очень важная часть вышеописанного кода. Этот символ указывает Python, что вы скоро вставите текст на его место. Если вы будете следовать за строкой со знаком процента и другой строкой или переменной, тогда Python попытается вставить ее в строку. Вы можете вставить несколько строк, добавив несколько знаков процента в свою строку. Это видно в последнем примере. Обратите внимание на то, что когда вы добавляете больше одной строки, вам нужно закрыть эти строки в круглые скобки. Теперь взглянем на то, что случится, если мы вставим недостаточное количество строк:


another_string = "Я люблю %s и %s" % "Python"

Traceback (most recent call last):

    File "<string>", line 1, in <fragment>

TypeError: not enough arguments for format string

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


my_string = "%i + %i = %i" % (1,2,3)

print(my_string) # '1 + 2 = 3'

float_string = "%f" % (1.23)

print(float_string) # '1.230000'

float_string2 = "%.2f" % (1.23)

print(float_string2) # '1.23'

float_string3 = "%.2f" % (1.237)

print(float_string3) # '1.24'

Первый пример достаточно простой. Мы создали строку, которая принимает три аргумента, и мы передаем их. В случае, если вы еще не поняли, Python не делает никаких дополнений в первом примере. Во втором примере, мы передаем число с запятой. Обратите внимание на то, что результат включает множество дополнительных нулей (1.230000). Нам это не нужно, так что мы указываем Python ограничить выдачу до двух десятичных значений в третьем примере (“%.2f”). Последний пример показывает, что Python округлит числа для вас, если вы передадите ему дробь, что лучше, чем два десятичных значения. Давайте взглянем на то, что произойдет, если мы передадим неправильные данные:


int_float_err = "%i + %f" % ("1", "2.00")

Traceback (most recent call last):

    File "<string>", line 1, in <fragment>

TypeError: %d format: a number is required, not str

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


int_float_err = "%i + %f" % (1, "2.00")

Traceback (most recent call last):

    File "<string>", line 1, in <fragment>

TypeError: float argument required, not str

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

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

Этот метод был добавлен в Python 2.4 в виде шаблонов строк, но в качестве обычного метода string, работающего через метод format в версии 2.6. Так что это не самый свежий метод, просто обновленный. В любом случае, приступим к работе с шаблонами!


print("%(lang)s is fun!" % {"lang":"Python"}) # Python is fun!

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


a = "%(value)s %(value)s %(value)s !" % {"value":"SPAM"}

print(a) # SPAM SPAM SPAM !

b = "%(x)i + %(y)i = %(z)i" % {"x":1, "y":2}

print(b)

Traceback (most recent call last):

   File "<string>", line 1, in <fragment>

KeyError: 'z'

c = "%(x)i + %(y)i = %(z)i" % {"x":1, "y":2, "z":3}

print(c) # 1 + 2 = 3

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


a = "Python is as simple as {0}, {1}, {2}".format("a", "b", "c")

print(a) # 'Python is as simple as a, b, c'

b = "Python is as simple as {1}, {0}, {2}".format("a", "b", "c")

print(b) # 'Python is as simple as b, a, c'

xy = {"x":0, "y":10}

c = "Graph a point at where x={x} and y={y}".format(**xy)

print(c) # Graph a point at where x=0 and y=10

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

Подведем итоги

Мы проработали большой объем в данной статье. Давайте разберемся:
Сначала мы узнали, как создавать строки, после чего мы перешли к вопросу об их конкатенации. После этого, мы взглянули на несколько методов, которые предлагает нам объект string. Далее, мы рассмотрели нарезку строк и закончили замещением строк.


Так же в этом разделе:
 
MyTetra Share v.0.59
Яндекс индекс цитирования