Функция str python – Интерактивный учебник языка Python

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

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

# -*- 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. Далее, мы рассмотрели нарезку строк и закончили замещением строк.

python-scripts.com

Что такое объекты типа str в Python

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

Литералы строк

Существует несколько способов записи строк. Самыми популярными являются кавычки и апострофы. Они взаимозаменяемы и их использование позволяет исключить символ обратного слеша «\»:

• >>>Пример_1 = «Так записываются строки»

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

• >>>Пример_2 = «««Приблизительный набор слов для «блочной строки» в Питоне»»»

Базовые операции

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

• >>>Стр_1 = «FB» #Присваиваем значение
• >>>Стр_1
• «FB»
• >>>Стр_2 = Стр_1 + «.» + «ru» #выполняем конкатенацию
• >>>Стр_2
• «FB.ru»
• >>>Стр_3 = «O» * 3 + «PS!» #повторение и конкатенация
• >>>Стр_3
• «OOOPS!»
• >>>len(Стр_3) #вычисление длины
• 6

Так как в Python str являются неизменяемыми типами, каждая операция создает новый строковый объект.

Индексирование строк

К каждому элементу строки можно обращаться по его позиции или по порядковому номеру. Отсчет начинается не с привычной единицы, а с нуля. Для работы с индексами используются квадратные скобки. Поэтому если вы хотите извлечь второй символ, вам нужно передать интерпретатору команду «имя объекта»[1]:

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

Преобразование строк

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

• >>>5+ «dogs» + «run»
• Traceback (most recent call last): … TypeError
• >>>str(5) + « dogs » + « run.»
• «5 dogs run.»

Вместо str() допускается использование другой функции repr(). Она также выполняет преобразование, но возвращает объект в качестве строчки кода в расширенном варианте.

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

Синтаксически конструкция использования строковых методов выглядит следующим образом: «объект.метод(аргумент)».

• >>>l= «ggffkkllrr»
• >>>l.replace(«ff», «gg»)
• «ggggkkllrr»

В примере использовался способ замены элементов .replace(). Этот универсальный метод в качестве аргументов принимает строки любой длины и выполняет глобальный поиск с последующей заменой.

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

fb.ru

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

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

str = ‘Hellow World!’ str = «Hellow World!» str = «»»Sunday Monday Tuesday»»»

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

Чтобы символы доступа из String, используйте квадратные скобки [] для нарезки вместе с индексом или индексами для получения ваших символов. Индекс строки Python начинается с 0.

str = ‘Hellow World!’ print(str [0]) # output is «H» print(str [7]) # output is «W» print(str [0:6]) #output is Hellow print(str [7:12]) #output is World

Python допускает отрицательную индексацию для своих последовательностей.

Индекс -1 относится к последнему элементу, -2 ко второму последнему пункту и так далее.

print(str [0:-6]) # output is Hellow print(str [7:-1]) # output is World

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

Объединение двух или более строк в одну называется конкатенацией. Python использует оператор «+» для объединения одной или нескольких строк

str1 = ‘Hellow ‘ str2 = ‘ World!’ print(str1 + str2)

Вывод:

Reverse a String

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

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

Он работает, выполняя [begin: end: step] — оставив начало и конец и задавая шаг -1, он меняет строку.

str = ‘Python String’ print(str[::-1])

Вывод:

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

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

Длина строки len() в Python

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

str = «Hellow World!» print(len(str))

Вывод:

Метод Count() для подсчета подстрок в строке в Python

Метод String count () возвращает количество вхождений подстроки в данной строке.

str = «Python is Object Oriented» substr = «Object» print(str.count(substr))

Вывод:

Метод Index() индекса подстроки в строке в Python

Метод String index() возвращает индекс подстроки внутри данной строки.

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

str = «Python is Object Oriented» substr = «is» print(str.index(substr))

Вывод:

Преобразование букв в верхний регистр в Python

String upper() преобразует данную строку в буквы верхнего регистра и возвращает новую строку.

str = «Python is Object Oriented» print(str.upper())

Вывод:

PYTHON IS OBJECT ORIENTED

Преобразование букв в нижний регистр в Python

Строка lower () преобразует данную строку в строчные буквы и возвращает новую строку.

str = «Python is Object Oriented» print(str.lower())

Вывод:

python is object oriented

Метод startswith() в Python

Метод String startswith() возвращает Boolean TRUE, если строка начинается с указанной подстроки в противном случае, она вернет False.

str = «Python is Object Oriented» print(str.startswith(«Python»)) print(str.startswith(«Object»))

Вывод:

Метод endswith() в Python

Метод String endswith() возвращает Boolean TRUE, если строка заканчивается с указанной подстрокой в ​​противном случае возвращает False.

str = «Python is Object Oriented» print(str.endswith(«Oriented»)) print(str.endswith(«Object»))

Вывод:

Разбиение строки на более мелкие Split()

Метод String split () разбивает строку на более мелкие строки на основе разделителя или символа.

str = ‘Python is Object Oriented’ print(str.split())

Вывод:

[‘Python’, ‘is’, ‘Object’, ‘Oriented’]

Пример:

str = ‘Python,is,Object,Oriented’ print(str.split(‘,’))

Вывод:

[‘Python’, ‘is’, ‘Object’, ‘Oriented’]

Пример:

str = ‘Python,is,Object,Oriented’ print(str.split(‘,’,2))

Вывод:

[‘Python’, ‘is’, ‘Object,Oriented’]

Возвращение разделенной строки в виде списка в Python

str = ‘Python,is,Object,Oriented’ sList = str.split(‘,’) for temp in sList: print (temp)

Вывод:

Python is Object Oriented

Метод join() Python String

String join() — это строковый метод, который возвращает строку, конкатенированную с элементами итерабельного.

str = «Python is Object Oriented» tmp = «-« print (tmp.join(str))

Вывод:

P-y-t-h-o-n- -i-s- -O-b-j-e-c-t- -O-r-i-e-n-t-e-d

Метод find() индекс первого вхождения строки в Python

String find () возвращает индексную позицию первого вхождения указанной строки. Он вернет -1, если указанная строка не найдена.

str = «Python is Object Oriented» st = «Object» print (str.find(st)) print (str.find(st,20)) #finding from 20th position

Вывод:

Метод strip() удаление символов из строки в Python

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

str = » Python is Object Oriented « print (str.strip())

Вывод:

Python is Object Oriented

Метод rstrip() копировать строку с удаленными символами

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

str = » Python is Object Oriented « print (str.rstrip())

Вывод:

Python is Object Oriented

Метод lstrip()

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

str = » Python is Object Oriented « print (str.lstrip())

Вывод:

Python is Object Oriented

Источник: net-informations.com

bunkerbook.ru

Строки. Функции и методы строк — Документация Python Summary 1

# Литералы строк
S = 'str'; S = "str"; S = '''str'''; S = """str"""
# Экранированные последовательности
S = "s\np\ta\nbbb"
# Неформатированные строки (подавляют экранирование)
S = r"C:\temp\new"
# Строка байтов
S = b"byte"
# Конкатенация (сложение строк)
S1 + S2
# Повторение строки
S1 * 3
# Обращение по индексу
S[i]
# Извлечение среза
S[i:j:step]
# Длина строки
len(S)
# Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.find(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.rfind(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.index(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.rindex(str, [start],[end])
# Замена шаблона
S.replace(шаблон, замена)
# Разбиение строки по разделителю
S.split(символ)
# Состоит ли строка из цифр
S.isdigit()
# Состоит ли строка из букв
S.isalpha()
# Состоит ли строка из цифр или букв
S.isalnum()
# Состоит ли строка из символов в нижнем регистре
S.islower()
# Состоит ли строка из символов в верхнем регистре
S.isupper()
# Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы ('\f'), "новая строка" ('\n'), "перевод каретки" ('\r'), "горизонтальная табуляция" ('\t') и "вертикальная табуляция" ('\v'))
S.isspace()
# Начинаются ли слова в строке с заглавной буквы
S.istitle()
# Преобразование строки к верхнему регистру
S.upper()
# Преобразование строки к нижнему регистру
S.lower()
# Начинается ли строка S с шаблона str
S.startswith(str)
# Заканчивается ли строка S шаблоном str
S.endswith(str)
# Сборка строки из списка с разделителем S
S.join(список)
# Символ в его код ASCII
ord(символ)
# Код ASCII в символ
chr(число)
# Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.capitalize()
# Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.center(width, [fill])
# Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
S.count(str, [start],[end])
# Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.expandtabs([tabsize])
# Удаление пробельных символов в начале строки
S.lstrip([chars])
# Удаление пробельных символов в конце строки
S.rstrip([chars])
# Удаление пробельных символов в начале и в конце строки
S.strip([chars])
# Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.partition(шаблон)
# Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.rpartition(sep)
# Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.swapcase()
# Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.title()
# Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.zfill(width)
# Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
S.ljust(width, fillchar=" ")
# Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
S.rjust(width, fillchar=" ")

ps.readthedocs.io

Программирование на Python. Часть 2: Строки в питоне

Программирование на Python. Часть 2

Сергей Яковлев
Опубликовано 02.08.2010

Серия контента:

Этот контент является частью # из серии # статей: Программирование на Python. Часть 2

https://www.ibm.com/developerworks/ru/library/?series_title_by=**auto**

Следите за выходом новых статей этой серии.

Этот контент является частью серии:Программирование на Python. Часть 2

Следите за выходом новых статей этой серии.

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

1. Строковый тип.
2. Срезы (slicing).
3. Операции со строками.
4. Unicode.
5. Форматирование.
6. Встроенные методы.
7. Тест на конкатенацию.

1. Строковый тип

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

>>> word = 'strength'
>>> word[2] = 'y'  
TypeError: 'str' object does not support item assignment

Но если очень хочется, то изменить можно, например, так:

>>> word = word[:3] + '!' + word[4:]
'str!ngth'

Или так:

>>> word = word.replace('!','e')
'strength'

Индексы могут иметь отрицательные значения для отсчета с конца – отсчет начинается с -1:

>>> word[-1]     
h

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

>>> '123'
'123'
>>> "7'8''9"
"7'8''9"

Длинные строки можно разбивать на несколько строк с помощью обратного слеша:

>>> s = 'this is first word\
and this is second word'

Большие наборы строк и целые тексты можно заключать в тройные кавычки:

>>> print """
One
Two
Three
"""

Обратный слеш в строках используется для так называемой escape-последовательности.

После слеша может идти один или несколько символов.

В следующем примере комбинация ‘\n‘ – это новая строка, ‘\t‘ – это табуляция:

>>> s ='a\nb\tc'
>>> print s
a
b	c

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

>>> s = '\001\002\x03'
>>> s
'\x01\x02\x03'
>>> len(s)
3

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

2. Срезы

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

>>> word = 'strength'
>>> word[4]
n
>>> word[0:2]
st
>>> word[2:4]
re

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

>>> word[:3]
str
>>> word[5:]
gth

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

>>> s = '1234567890'
>>> s[::2]
'13579'
>>> s[1:10:2]
'13579'
>>> s[::-1]
'0987654321'

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

Строки можно склеивать с помощью оператора + :

>>> var = 'Moscow' + 'city'

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

Строки можно умножать с помощью оператора * :

>>> '123' * 3
'123123123'

Строки можно сравнивать с помощью операторов <, <=, ==, !=, >, >=.

4. Unicode

Unicode позволяет применять все символы, используемые в текстах на разных языках. Ранее мы могли использовать только 256 символов из определенной кодовой страницы. Перед строкой нужно поставить спецификатор u – при этом на каждый символ отводится 2 байта, так как по умолчанию ставится кодировка UTF-8:

>>> w = u'Вася Пупкин'
>>> w
u'\u0412\u0430\u0441\u044f \u041f\u0443\u043f\u043a\u0438\u043d'

Юникодную строку можно также создать в известной кодировке: ASCII, UTF-8, UTF-16, KOI8-R, CP1251, CP866 и т.д.:

>>> s = unicode("Привет", "KOI8-R")
>>> s
u'\u043f\xf7\u044f\u2500\u043f\u2566\u043f\u2561\u043f\u2563\u044f\u250c'

Метод encode() позволяет преобразовывать строки Unicode в обычные строки, содержащие текст в указанной кодировке:

>>> s.encode("KOI8-R")
'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82'

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

Форматирование в питоне – мощный инструмент управления строками. Есть несколько подходов – стандартный и с использованием шаблонов. Для форматирования в питоновских строках используется стандартный оператор – символ %. Слева от процента указываем строку, справа – значение или список значений:

>>> s = 'Hello %s' % 'word'
>>> s
'Hello word'

>>> s = 'one  %s %s' % ('two','three')
>>> s
'one  two three'

Если нужно преобразование числа в строку, используется числовой спецификатор – %d или %f:

>>> s = 'one  %d %f' % (2 , 3.5)
>>> s
'one  2 3.500000'

При форматировании можно указать общую ширину строки и точность для чисел, при этом число будет дополнено незначащими нулями. В следующем примере результирующая строка будет иметь длину 10 символов, на дробную часть будет отведено 5 символов:

>>> x = 4/3
>>> '%10.5f' % x
'   1.00000'

Пробелы слева можно отформатировать нулями:

>>> from math import pi
>>> '%015.10f' % pi
'0003.1415926536'

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

>>> from string import Template
>>> s = Template('1 $two 3 4 $five')
>>> d={}
>>> d['two']=2
>>> d['five']=5
>>> s.substitute(d)
'1 2 3 4 5'

Таблица типов форматирования для строк

6. Методы

Строки обладают большим набором разнообразных методов. Наиболее популярные из них:

find – находит подстроку в строке – возвращает позицию вхождения строки, либо -1:

>>> s = 'The find method finds a substring'
>>> s.find('find')
4
>>> s.find('finds')
16
>>> s.find('findsa')
-1

join – объединяет через разделитель набор строк:

>>> seq = ['one','two','three']
>>> sep = ','
>>> sep.join(seq)
'one,two,three'

split – это обратная функция для join, разбивает строку на последовательность:

>>> s = '/usr/local/bin'
>>> s.split('/')
['', 'usr', 'local', 'bin']

replace – заменяет в строке одну подстроку на другую:

>>> s = 'replace method returns a string'
>>> s.replace('returns','return')
'replace method return a string'

strip – удаляет пробелы слева и справа:

>>> '       this is whitespace string    '.strip()
'this is whitespace string'

translate – в отличие от replace, может делать множественную замену. В следующем примере каждый символ ‘1‘ в исходной строке будет заменен на символ ‘3‘, а символ ‘2‘ – на символ ‘4‘ соответственно:

>>> from string import maketrans
>>> table = maketrans('12', '34')
>>> '1212 5656'.translate(table)
'3434 5656'

Для конверсии различных типов в строковый используются функции str, int, ord, chr:

• str – конвертирует число в строку;
• int – конвертирует строку в число;
• ord – возвращает значение байта;
• chr – конвертирует число в символ.

Таблица методов, доступных в Python 3.0

7. Тест на конкатенацию

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

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

1-й метод. Используем для хранения строки массив символов array. Будем просто добавлять туда строковое представление натурального числа, а в конце применим метод array.tostring(). Этот метод оказался самым медленным.

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

3-й метод. Используем модуль cStringIO, в котором есть возможность писать в псевдо-файл, который на самом деле хранится в памяти. В конце вызываем метод getvalue().

4-й метод. Создаем в цикле список символьных представлений чисел, а потом одним махом джойним этот список. Отличие его от второго метода в том, что не используется append(). Вы увидите, что этот метод – самый быстрый.

Код:

import time

loop_count = 1000000

def method1():
  from array import array
  char_array = array('c') 
  for num in xrange(loop_count):
    char_array.fromstring(`num`)
  return char_array.tostring()
    
def method2():
  str_list = []
  for num in xrange(loop_count):
    str_list.append(`num`)
  return ''.join(str_list)
    
def method3():
  from cStringIO import StringIO
  file_str = StringIO()
  for num in xrange(loop_count):
    file_str.write(`num`)
  return file_str.getvalue()    
  
def method4():
  return ''.join([`num` for num in xrange(loop_count)])
    
t1 = time.time()
method1()
t2 = time.time()
print "\t%.1f" % ((t2 - t1))
method2()
t3 = time.time()
print "\t%.1f" % ((t3 - t2))
method3()
t4 = time.time()
print "\t%.1f" % ((t4 - t3))
method4()
t5 = time.time()
print "\t%.1f" % ((t5 - t4))

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

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

Ресурсы для скачивания

Подпишите меня на уведомления к комментариям

www.ibm.com