Strings and character data in python

Строковые функции, методы и операторы

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

Списки, так же как и строки могут «складываться» (соединяться) и «умножаться» (дублироваться):

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

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

С помощью оператора можно осуществлять перебор всех элементов любой последовательности в цикле :

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

Что бы посмотреть на список всех доступных строкам функций и методов достаточно передать функции какой-нибудь строковый объект:

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

Use the right tool for the job

For at least mildly knowledgeable Python programmer, the first thing that comes to mind is probably . It does pretty much the same thing as the version above, except instead of a value, you give it a value factory. That might cause some overhead, because the value has to be «constructed» for each missing key individually. Let’s see how it performs.

hope @AlexMartelli won’t crucify me for


Not that bad. I’d say the increase in execution time is a small tax to pay for the improved readability. However, we also favor performance, and we will not stop here. Let’s take it further and prepopulate the dictionary with zeros. Then we won’t have to check every time if the item is already there.

hats off to @sqram

That’s good. Over three times as fast as , yet still simple enough. Personally, this is my favorite in case you don’t want to add new characters later. And even if you do, you can still do it. It’s just less convenient than it would be in other versions:

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

Когда мы говорим «текстовая обработка», мы обычно подразумеваем обработку содержимого файла. На языке Python не составляет труда считать содержимое текстового файла в строковые переменные, где этим содержимым можно манипулировать. Файловые объекты обеспечивают три метода чтения: .read(), .readline(), and .readlines(). Каждый из этих методов может принимать аргумент для ограничения объема данных, считываемых за один раз, однако в основном они используются без аргумента. .read() считывает весь файл за один раз, и обычно используется для помещения содержимого файла в строковую переменную. Хотя .read() дает наиболее прямое строковое представление содержимого файла, он неудобен для последовательной строчно-ориентированной обработки файла, к тому же это невозможно, если размер файла превышает объем имеющейся памяти.

..readline() и .readlines() очень похожи. И та и другая используются в конструкциях наподобие следующей:

 fh = open('c:\\autoexec.bat')
for line in fh.readlines():
print line

Различие между .readline() и .readlines() в том, что последняя, как и .read(), считывает весь файл за один раз. .readlines() автоматически парсит содержимое файла в список строк, который может быть обработан с помощью конструкции языка Python for … in ….

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

Если вы используете стандартный модуль, работающий с файлами, вы можете превратить строку в «виртуальный файл» с помощью модуля cStringIO (если требуется создание производных классов, можно использовать StringIO, но начинающим это требуется редко).

Например:

cStringIO-модуль

>>> import

                                 cStringIO
>>> fh = cStringIO.StringIO()
>>> fh.write("mary had a little lamb")
>>> fh.getvalue()
'mary had a little lamb'
>>> fh.seek(5)
>>> fh.write('ATE')
>>> fh.getvalue()
'mary ATE a little lamb'

Не забывайте, однако, что, в отличие от настоящего файла, «виртуальный файл», сформированный cStringIO — временный. Он исчезнет, когда программа завершится, если вы не предпримете каких-либо шагов, чтобы его сохранить (например, запишете его в реальный файл или воспользуетесь модулем shelve либо базой данных).

Why Python strip function is used?

Here, are reasons for using Python strip function

  • It helps to remove the characters at the start of the string and also at the end of the string based on the characters given to be removed from the original string.
  • If the characters given do not match the original string, the string will be returned as it is.
  • If the characters to be removed are not specified, then the whitespaces from the start and end of the original string will be removed.
  • If there is no white space at the start or end than the string will be returned as it is.

Summary:

  • The strip() function is part of the built-in function available in python. The function will remove given characters from the start and end of the original string.
  • This function is very helpful in removing the whitespaces at the start and end of the given string, as shown in the example.
  • It helps to remove the characters at the start of the string and also at the end of the string based on the characters given to be removed from the original string.
  • If the characters given do not match the original string, the string will be returned as it is.
  • If the characters to be removed are not specified, the whitespaces from the start and end of the original string will be removed.
  • If there is no white space at the start or end than the string will be returned as it is.

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

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

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

Чтобы конвертировать число в строку, используйте метод str(). Поместите число или переменную в круглые скобки.

Попробуйте преобразовать целое число, например:

Запустив метод str(12) в интерактивной оболочке Python (с помощью команды python), вы получите вывод:

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

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

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

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

Теперь, запустив код, вы увидите:

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


Попробуйте выполнить конкатенацию строки и преобразованного в строку числа:

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

Строки можно преобразовать в числа с помощью методов int() и float()

Если в строке нет десятичных знаков, лучше преобразовать её в целое число. Для этого используется int().

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

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

Значение переменной lines_more – это число, в данном случае это 58.

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

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

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

Конвертируйте эти строки в числа с плавающей точкой, а затем выполните сложение.

Как видите, теперь программа возвращает ожидаемый результат.

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

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

Чтобы преобразовать данные в кортеж или список, используйте методы tuple() и list() соответственно. В Python:

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

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

Преобразовывая список в кортеж, вы можете оптимизировать программу. Для преобразования в кортеж используется метод tuple().

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


Попробуйте использовать tuple() с переменной:

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

Конвертируя в кортеж числовой тип данных, вы получите ошибку:

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

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

Обратите внимание: при этом в методах list() и print() используется две пары круглых скобок. Одни принадлежать собственно методу, а другие – кортежу

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

Чтобы избежать путаницы с круглыми скобками, можно создать переменную:

Строки тоже можно преобразовывать в списки:

Practicality beats purity (except when it’s not really practical)

Now a bit different kind of counter. @IdanK has come up with something interesting. Instead of using a hash table (a.k.a. dictionary a.k.a. ), we can avoid the risk of hash collisions and consequent overhead of their resolution. We can also avoid the overhead of hashing the key, and the extra unoccupied table space. We can use a . The ASCII values of characters will be indices and their counts will be values. As @IdanK has pointed out, this list gives us constant time access to a character’s count. All we have to do is convert each character from to using the built-in function . That will give us an index into the list, which we will then use to increment the count of the character. So what we do is this: we initialize the list with zeros, do the job, and then convert the list into a . This will only contain those characters which have non-zero counts, in order to make it compliant with other versions.

As a side note, this technique is used in a linear-time sorting algorithm known as count sort or counting sort. It’s very efficient, but the range of values being sorted is limited, since each value has to have its own counter. To sort a sequence of 32-bit integers, 4.3 billion counters would be needed.

Ouch! Not cool! Let’s try and see how long it takes when we omit building the dictionary.

Still bad. But wait, what’s ? Can’t we write it more simply? How about ? That’s cleaner. But will it perform better?

Considerably. Now let’s put the dictionary back in.

Almost six times slower. Why does it take so long? Because when we , we have to check every one of the 256 counts and see if it’s zero. But we already know which counts are zero and which are not.

It probably won’t get much better than that, at least not for such a small input. Plus it’s only usable for 8-bit EASCII characters. О блять!

And the winner is…

Yep. Even if you have to check every time whether is in , for this input it’s the fastest way. No pre-population of will make it faster (again, for this input). It’s a lot more verbose than or , but also more efficient.

That’s all folks

This little exercise teaches us a lesson: when optimizing, always measure performance, ideally with your expected inputs. Optimize for the common case. Don’t presume something is actually more efficient just because its asymptotic complexity is lower. And last but not least, keep readability in mind. Try to find a compromise between «computer-friendly» and «human-friendly».

UPDATE

I have been informed by @MartijnPieters of the function available in Python 3.

Help on built-in function _count_elements in module _collections:

_count_elements(...)
    _count_elements(mapping, iterable) -> None

    Count elements in the iterable, updating the mappping

This function is implemented in C, so it should be faster, but this extra performance comes at a price. The price is incompatibility with Python 2 and possibly even future versions, since we’re using a private function.

From the :

That said, if you still want to save those 620 nanoseconds per iteration:

UPDATE 2: Large strings

I thought it might be a good idea to re-run the tests on some larger input, since a 16 character string is such a small input that all the possible solutions were quite comparably fast (1,000 iterations in under 30 milliseconds).

I decided to use the complete works of Shakespeare as a testing corpus, which turned out to be quite a challenge (since it’s over 5MiB in size ). I just used the first 100,000 characters of it, and I had to limit the number of iterations from 1,000,000 to 1,000.

was really slow on a small input, but the tables have turned

Naïve Θ(n2) time dictionary comprehension simply doesn’t work

Smart Θ(n) time dictionary comprehension works fine

Exceptions are clumsy and slow

Omitting the exception type check doesn’t save time (since the exception is only thrown a few times)

looks nice but runs slow


isn’t very fast either

requires reading the (very long) string twice

Using instead of is neither nice nor fast

Leaving out the final conversion to doesn’t help

It doesn’t matter how you construct the , since it’s not the bottleneck

If you convert to the «smart» way, it’s even slower (since you iterate over the string twice)

The variant may be fast for small strings, but not so much for big ones

is about as fast as (which uses internally)

Final verdict: Use unless you cannot or don’t want to 🙂

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

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

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

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

#!/usr/bin/python

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

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

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

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

Каждый символ, который указан в такой строке будет отображён «как есть»:

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

#!/usr/bin/python

print 'C:nowhere'

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

C:nowhere

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

#!/usr/bin/python

print r'C:nowhere'

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

C:nowhere

С этим читают