§ 9.7. Строки

Школьный курс C++
Содержание

Символ и строка в python. Тип str

Текстовые данные в Python обрабатываются с помощью объектов класса str или строк. Строка – это неизменяемая последовательность кодов символов Unicode. Такая реализация отличает Python от других языков программирования (например, C/C++) в которых строка – это обычный (изменяемый) массив, последним символом которого является завершающий символ ('\0'). С любой неизменяемой последовательностью работа осуществляется значительно быстрее. А так как python скриптовый язык широко применяемый в администрировании системы, работа со строкой должна производиться максимально эффективно на столько, на сколько это возможно.
Тогда как же изменить строку? Стратегия обработки строк заключается в замене (переприсваивании) существующей строки на новую. Что касается инструментария python для обработки строк, то его набор ничем не уступает набору соответствующих функций в других языках программирования.
Строковый литерал заключается в одинарные, двойные, утроенные одинарные или утроенные двойные кавычки:

S1 = 'Это строка'
S2 = "Это тоже строка"
S3 = '''А это очень большой фрагмент текста'''

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

S = """
Использовать 'одинарные' или "двойные" кавычки,
внутри таких блоков - разрешается.
Символы перехода на новую строку будут
добавлены автоматически. Но это \
можно отменить 
с помощью символа "\\"
"""
print(S)

Вывод

Использовать 'одинарные' или "двойные" кавычки,
внутри таких блоков - разрешается.
Символы перехода на новую строку будут
добавлены автоматически. Но это можно отменить 
с помощью символа "\"

Внутри одинарных кавычек можно использовать двойные и наоборот.
В отличие от многих языков программирования, в python отсутствует символьный тип. Даже “одиночный” символ является строкой. Объект любого встроенного типа можно преобразовать в строку с помощью одноименной функции преобразования str():

I = 1000 # Целый
F = 3.14 # Действительный
C = 1 + 2j # Комплексный
D = {'a': 1, 'b': 'B'} # Словарь
T = 1, 2, 3, 4, 5 # Кортеж
L = [1, 2, 3, 4, 5] # Список
print(str(I), str(F), str(C), str(D), str(T), str(L), sep='\n')

Вывод

1000
3.14
(1+2j)
{'a': 1, 'b': 'B'}
(1, 2, 3, 4, 5)
[1, 2, 3, 4, 5]

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

print("Москва" > "Питера")
print("Moon" < "Sun")
False
True

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

Строка как последовательность

Как и список, строка индексируется начиная с 0 и каждый символ можно рассматривать как отдельный элемент массива. Решим задачу.
Задача 1. Дана строка S. Определить количество слов в этой строке.

Программа 9.7.1
S = input('S => ')
k = 0
for j in S:
    if j == ' ':
        k += 1
print('Количество слов в строке:', k + 1)

Вывод

S => Ветер по морю гуляет И кораблик подгоняет; Он бежит себе в волнах На поднятых парусах
Количество слов в строке: 15

В этой задаче мы осуществляем подсчет пробельных символов. Соответственно, количество слов будет на единицу больше.
С объектами str применяются общие операции для последовательностей, с которыми мы познакомились в предыдущем параграфе. Решим задачу с помощью этих операций.
Задача 2. Дана строка S. Определить, есть ли в строке S символ сh. Если таких символов несколько, то определить позиции первого и последнего символа.

Программа 9.7.2
S = input('S => ')
ch = input('ch => ')
if ch in S:
    print('Такой символ есть в строке!')
    if S.count(ch) > 1:
        print('Первый символ находится на',
              S.index(ch),
              'позиции\nВторой символ находится на',
              len(S) - S[::-1].index(ch) - 1,
              'позиции')
else:
    print('Такого символа в строке нет!')

Вывод

S => А роза упала на лапу Азора
ch => у
Такой символ есть в строке!
Первый символ находится на 7 позиции
Второй символ находится на 19 позиции
------------------
S => Абракадабра
ch => к
Такой символ есть в строке!
------------------
S => Абракадабра
ch => ?
Такого символа в строке нет!

В выражении

S[::-1]

применяется синтаксис срезов. Это выражение означает "развернуть строку". О срезах см. ниже.

Escape-последовательности и преобразования символов

Escape-последовательности (или управляющие последовательности) используются для описания специальных символов внутри строковых литералов.

Escape-последовательности
Символ Описание
\newline backslash, игнорирует переход на новую строку
\\ backslas
\' Одинарная кавычка
\" Двойная кавычка
\a Звуковой сигнал (ASCII Bell (BEL))
\b Забой (ASCII Backspace (BS))
\f Новая страница (ASCII Formfeed (FF))
\n Новая строка (ASCII Linefeed (LF))
\r Возврат каретки (ASCII Carriage Return (CR))
\t Горизонтальная табуляция (ASCII Horizontal Tab (TAB))
\v Вертикальная табуляция (ASCII Vertical Tab (VT))
\ooo Символ с восьмеричным значением
\xhh Символ с шестнадцатеричным значением
\N{name} Имя символа в базе данных Unicode
\uxxxx Символ с 16-битным шестнадцатеричным значением
\Uxxxxxxxx Символ с 32-битным шестнадцатеричным значением
Escape-последовательности будут проигнорированы, если строковый литерал использует префикс r. В таблице отсутствует последовательность \0, но это не ошибка. В python такой последовательности не существует.

Escape-последовательности мы применяли и ранее - для упрощения форматированного вывода (\t или \n). В программе ниже используется символ горизонтальной табуляции ('\t'), чтобы оформить вывод в три столбца (табуляцию можно вполне заменить указанием ширины вывода в format()).
Задача 3. Выведите кодировочную таблицу ASCII c 32 (space) по 127 (del) символ.

Программа 9.7.3
print('{0:^3}{1:>3}{2:>5}\t\t{0:^3}{1:>3}{2:>5}\t\t{0:^3}{1:>3}{2:>5}'
      .format('№', '->', 'Сим.'))
for j in range(32, 64):
    print('{:>3}{:>3}{:>2}\t\t{:>3}{:>3}{:>2}\t\t{:>3}{:>3}{:>2}'
          .format(j, '->', chr(j),
                  j + 32, '->', chr(j + 32),
                  j + 64, '->', chr(j + 64)))

Вывод

 №  -> Сим.		 №  -> Сим.		 №  -> Сим.
 32 ->  		 64 -> @		 96 -> `
 33 -> !		 65 -> A		 97 -> a
 34 -> "		 66 -> B		 98 -> b
 35 -> #		 67 -> C		 99 -> c
 36 -> $		 68 -> D		100 -> d
 37 -> %		 69 -> E		101 -> e
 38 -> &		 70 -> F		102 -> f
 39 -> '		 71 -> G		103 -> g
 40 -> (		 72 -> H		104 -> h
 41 -> )		 73 -> I		105 -> i
 42 -> *		 74 -> J		106 -> j
 43 -> +		 75 -> K		107 -> k
 44 -> ,		 76 -> L		108 -> l
 45 -> -		 77 -> M		109 -> m
 46 -> .		 78 -> N		110 -> n
 47 -> /		 79 -> O		111 -> o
 48 -> 0		 80 -> P		112 -> p
 49 -> 1		 81 -> Q		113 -> q
 50 -> 2		 82 -> R		114 -> r
 51 -> 3		 83 -> S		115 -> s
 52 -> 4		 84 -> T		116 -> t
 53 -> 5		 85 -> U		117 -> u
 54 -> 6		 86 -> V		118 -> v
 55 -> 7		 87 -> W		119 -> w
 56 -> 8		 88 -> X		120 -> x
 57 -> 9		 89 -> Y		121 -> y
 58 -> :		 90 -> Z		122 -> z
 59 -> ;		 91 -> [		123 -> {
 60 -> <		 92 -> \		124 -> |
 61 -> =		 93 -> ]		125 -> }
 62 -> >		 94 -> ^		126 -> ~
 63 -> ?		 95 -> _		127 -> 

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

  • ord() – возвращает значение байта;
  • chr() – возвращает символ по его коду.
С помощью этих функций можно вывести не только "Аски", но и любой сегмент Unocode, например, кириллический. Известно, что начинается он с буквы 'Ѐ', которая имеет номер в таблице Unicode - U+0400 (102410). Но знать это совершенно не обязательно! Если известен диапазон сегмента, то его можно вывести так, как показано в программе 9.7.4.
Задача 4. Выведите неполный кириллический сегмент таблицы Unicode (диапазон значений U+0400 - U+048B, всего 140 символов).

Программа 9.7.4
k = 0
for i in range(20):
    for j in range(7):
        print(chr(ord('\u0400') + k), '\t', end='')
        k += 1
    print()

Вывод

Ѐ 	Ё 	Ђ 	Ѓ 	Є 	Ѕ 	І 	
Ї 	Ј 	Љ 	Њ 	Ћ 	Ќ 	Ѝ 	
Ў 	Џ 	А 	Б 	В 	Г 	Д 	
Е 	Ж 	З 	И 	Й 	К 	Л 	
М 	Н 	О 	П 	Р 	С 	Т 	
У 	Ф 	Х 	Ц 	Ч 	Ш 	Щ 	
Ъ 	Ы 	Ь 	Э 	Ю 	Я 	а 	
б 	в 	г 	д 	е 	ж 	з 	
и 	й 	к 	л 	м 	н 	о 	
п 	р 	с 	т 	у 	ф 	х 	
ц 	ч 	ш 	щ 	ъ 	ы 	ь 	
э 	ю 	я 	ѐ 	ё 	ђ 	ѓ 	
є 	ѕ 	і 	ї 	ј 	љ 	њ 	
ћ 	ќ 	ѝ 	ў 	џ 	Ѡ 	ѡ 	
Ѣ 	ѣ 	Ѥ 	ѥ 	Ѧ 	ѧ 	Ѩ 	
ѩ 	Ѫ 	ѫ 	Ѭ 	ѭ 	Ѯ 	ѯ 	
Ѱ 	ѱ 	Ѳ 	ѳ 	Ѵ 	ѵ 	Ѷ 	
ѷ 	Ѹ 	ѹ 	Ѻ 	ѻ 	Ѽ 	ѽ 	
Ѿ 	ѿ 	Ҁ 	ҁ 	҂ 	҃ 	҄ 	
҅ 	҆ 	҇ 	҈ 	҉ 	Ҋ 	ҋ
Табуляция в этой программе применяется для того, чтобы предупредить переменную ширину выводимых символов.

Строки и списки

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

Программа 9.7.5
S = "Это строка символов"
L = S.split(' ')
L2 = list(S)
S2 = ''.join(L2)
print(S)
print(L)
print(L2)
print(S2)

Вывод

Это строка символов
['Это', 'строка', 'символов']
['Э', 'т', 'о', ' ', 'с', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
Это строка символов

В данной программе список L содержит слова исходной строки S, полученные с помощью метода split(). Элементами списка L2 являются символы строки S. Для того, чтобы список символов вновь стал строкой (S2) необходимо применить метод join() (обратный методу split()).

Срезы

Ранее мы уже показали, что доступ к элементу последовательности можно получить обратившись по индексу и имени, например: S[0] — первый элемент, S[1] — второй и т. д. Последний элемент последовательности в которой содержится N элементов будет иметь индекс равный N-1 (S[N-1]). Однако в python можно использовать и отрицательную индексацию.
Пусть дана некоторая последовательность Seq, состоящая из 10 элементов. Тогда к последнему элементу можно обратиться так: Seq[-1] (или Seq[9]), к предпоследнему Seq[-2] и т. д. В итоге, первый элемент — Seq[-10] (он же и Seq[0]).

Такое представление индекса очень удобно, если необходимо проводить некоторые операции с конца последовательности. Отрицательная индексация нашла своё применение в срезах.
Срезы (англ. - slices) — операции над последовательностями, которые производят выборку определенных элементов массива с помощью индексов. Срезы можно получать для любой последовательности. Синтаксис срезов выглядит следующим образом:

Seq[start:stop:step]
  • start — индекс начала среза (индексы могут быть отрицательными),
  • stop — индекс конца среза ([start, stop)),
  • step — шаг (может быть отрицательным).
start, stop и step могут быть только целыми числами или целочисленными переменными. Индекс stop не включается в срез.
Срезы позволяют выполнять довольно сложные алгоритмы, запись которых выглядит очень компактно. Обычно срезы используются для создания новых последовательностей. Срезы можно использовать в различных операциях, например, конкатенации, сортировки, замены, поиска и т. п. Если осуществляется попытка получить срез несуществующих элементов, то будет возвращена пустая последовательность.
Срез Seq[:] будет означать выбор всей последовательности, тогда копию последовательности Seq можно создать так:

B = Seq[:]

Последняя операция будет аналогична такой:

B = str(Seq)
Обратите внимание, что операция B = Seq создаёт новую ссылку (а не копию) на эту же последовательность Seq!

Приведем примеры:

Программа 9.7.6
Seq = 'Это символьная строка'
print(Seq[0:3])
print(Seq[-6:])
print(Seq[-17:-7])
print(Seq[:14])

Вывод

Это
строка
символьная
Это символьная

Отсутствие одного из индексов означает, что выполняется срез либо от начала (отсутствует start, стр. 5) до указанного индекса, либо до конца (отсутствует stop, стр. 3) от указанного индекса в последовательности.
Отрицательный шаг позволяет выполнять срезы с конца массива. Например:

Программа 9.7.7
Seq = 'Это символьная строка'
print(Seq[::-1]) # Реверс строки
print(Seq[-6::-2]) # начиная с [-6] ('c'), справа налево (к началу), через один
print(Seq[:6:-2]) # начиная с конца и до [6] ('м', не входит), справа налево, через один

Вывод

акортс яаньловмис отЭ
сянлви т
аот аьо

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

Есть ограничение! Нельзя целевой изменяемой последовательности (получаемой в виде среза) присвоить значения среза имеющего больший размер! (Генерируется исключение)

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

Программа 9.7.8
Seq = 'Это символьная строка'
Seq = Seq[0:3] + Seq[14:] + Seq[3:14]
print(Seq)

Вывод

Это строка символьная

Методы класса str

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

S = S.replace(S1, S2)
Методы класса str
Метод Описание
S.find(S1[, start[, end]]) Поиск подстроки S1 в строке S. Возвращает позицию первого вхождения или -1. Необязательные аргументы start и end интерпретируются как срез
S.rfind(S1[, start[, end]]) Поиск подстроки S1 в строке S. Возвращает позицию последнего вхождения или -1. Необязательные аргументы start и end интерпретируются как срез
S.index(S1[, start[, end]]) Аналогичен find(), но вызывает ошибку ValueError, если подстрока не найдена.
S.replace(S1, S2[, count]) Заменяет подстроку S1 подстрокой S2 не больше, чем первые count вхождений
S.split(char) Получение списка по разделителю char
S.splitlines() Получение списка строк разбитых символом разрыва строки (не включается в результирующий список)
S.isdigit() Состоит ли строка из цифр (True, если да)
S.isalpha() Состоит ли строка из букв
S.isalnum() Состоит ли строка из цифр или букв
S.islower() Состоит ли строка из символов в нижнем регистре
S.isupper() Состоит ли строка из символов в верхнем регистре
S.isspace() Состоит ли строка из пробельных символов
S.upper() Преобразование строки к верхнему регистру
S.lower() Преобразование строки к нижнему регистру
S.join(list) Сборка строки из списка с разделителем S
S.center(width[, fill]) Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.count(S1[, start[, end]]) Возвращает количество непересекающихся вхождений подстроки S1
S.strip() Удаление пробельных символов в начале и в конце строки
S.format(*args, **kwargs) Форматирование строки

Приведем примеры решения задач с помощью методов str.
Задача 5. Дана строка S, содержащая символы '-'. Заменить в этой строке все найденные символы '-' на символ '#'. Изменить строку S так, чтобы все символы были переведены в верхний регистр (сделать все символы прописными).

Программа 9.7.9
S = 'q-q-q-q-q-q-q-q-q-q-q'
print(S)
S = S.replace('-', '#')
print(S)
if S.islower():
	S = S.upper()
print(S)

Вывод

q-q-q-q-q-q-q-q-q-q-q
q#q#q#q#q#q#q#q#q#q#q
Q#Q#Q#Q#Q#Q#Q#Q#Q#Q#Q

Строку, по определенным критериям, можно "собрать" в цикле благодаря операции конкатенации. Алгоритм напоминает накопление суммы в цикле. Отличием здесь является то, что начальным значением накопителя является пустая строка. Рассмотрим пример использования данной операции на примере решения задачи №12 (КЕГЭ). Заметим, что данную задачу можно решить и аналитически.
Задача 6. Исполнитель Редактор получает на вход строку цифр и преобразовывает её. Какая строка получится в результате применения приведённой ниже программы к строке, состоящей из 81 идущей подряд цифры 1? В ответе запишите полученную строку.

НАЧАЛО
    ПОКА нашлось (1111) ИЛИ нашлось (88888)
        ЕСЛИ нашлось (1111) ТО 
            заменить (1111, 888)
        ИНАЧЕ 
            заменить (88888, 888)
        КОНЕЦ ЕСЛИ
    КОНЕЦ ПОКА
КОНЕЦ

(Задача дана в сокращении. Полный вариант задачи см. здесь)

Программа 9.7.10
#############Получаем строку:############
S = '1' * 81
#############Решаем задачу:##############
while '1111' in S or '88888' in S:
    if '1111' in S:
        S = S.replace('1111', '888', 1)
    else:
        S = S.replace('88888', '888', 1)
else:
    print(S)

Вывод

88881

Для решения данной задачи мы должны переписать псевдокод условия на языке python. Для этого нужно логическую функцию нашлось(), функцию заменить(), а также конструкции "ПОКА" и "ЕСЛИ" заменить на соответствующие функции и конструкции языка python.
Поиск подстроки в строке можно осуществлять с помощью методов find(), rfind(), index() и rindex(). Последние две генерируют исключение (исключения рассматриваются в базовом курсе). Узнать о количестве вхождений можно с помощью стандартной функции count().
Задача 7. Дана строка S. Определить сколько раз строка S0 входит в строку S и вывести все позиции этих вхождений. Если подстроки S0 нет в строке S, то сообщить об этом.

Программа 9.7.11
S = input('Строка => ')
S0 = input('Подстрока => ')
pos, i = 0, 0
if S.count(S0): # Если количество подстрок != 0,
    print('Количество вхождений:', S.count(S0))
    while i < S.count(S0): # то выполняем соотв. кол-во шагов
        i += 1
        print(i, '=>', S.find(S0, pos, len(S))) # выводим позицию
        pos = S.find(S0, pos, len(S)) + len(S0) # и переходим к следующему
else:
    print('Такой подстроки нет.')

Вывод

Строка => qqqqwwqqqqqqqqwwwwqqqq
Подстрока => ww
Количество вхождений: 3
1 => 4
2 => 14
3 => 16

Удаление подстроки можно осуществить с помощью метода replace(), вторым аргументом которого будет пустая строка.
Задача 8. Дана строка S. Удалить каждое вхождение подстроки S0 в строке S. Гарантируется, что подстрока S0 есть в строке S.

Программа 9.7.12
S = input('Строка => ')
S0 = input('Подстрока => ')
S = S.replace(S0, '')
print(S)

Вывод

Строка => qqqqwwqqqqqqqqwwwwqqqq
Подстрока => ww
qqqqqqqqqqqqqqqq

Строку можно изменить, если её преобразовать в список и использовать методы работы со списком. Решим следующую задачу именно таким способом.
Задача 9. Дана строка S. Удалить из этой строки все повторяющиеся символы, следующие друг за другом, оставив только по одному символу.

Программа 9.7.13
S = input('Строка => ')
L = list(S)
i = 1
while i < len(L): 
    if L[i] == L[i-1]:
        L.pop(i)
    else:
        i += 1
else:
    S = ''.join(L)
print(S)

Вывод

Строка => aaassdddddddfghhjkllzz
asdfghjklz

Одна и таже задача со строками может быть решена различными способами. Выбор способа решения зависит от разработчика, но нужно иметь в виду, что не все способы равнозначны с точки зрения эффективности. К этому следует добавить, что существующие реализации python могут показать разную эффективность выполнения одного и того же алгоритма. Окончательный выбор нужно делать исходя из результатов тестирования. Приведем пример, в котором мы производим замер скорости выполнения двух фрагментов программы выполняющих одну и туже задачу. Для этого воспользуемся модулем timeit.
Задача 10. Дана непустая строка S и целое число N (> 0). Вывести строку, содержащую символы строки S, между которыми вставлено по N символов ch (вводится с клавиатуры).

Программа 9.7.14
S = input('S => ') # Вводим оч. большую строку
N = int(input('N => ')) # и оч. длинную последовательность символов
ch = input('ch => ')
ch = N * ch
k = len(S)
import timeit
################ 1 вариант ##################
# Без использования списка
S1 = str(S)
a = timeit.default_timer() # начальный момент времени
temp = '' # Создаем пустую строку
for j in range(k):
    temp = temp + S1[j] + ch
S1 = temp[:-len(ch)] # отбросить N последних
t1 = timeit.default_timer() - a # продолжительность в долях сек.
# print(S1)
################ 2 вариант ##################
# С использованием списка
S2 = str(S)
a = timeit.default_timer()
L = list(S2) # Превращаем строку в список
for j in range(1, 2 * k - 1, 2):
    L.insert(j, ch)    
S2 = ''.join(L) # Восстанавливаем строку
t2 = timeit.default_timer() - a
# print(S2)  
print('Время выполнения фрагмента без\nиспользования списка:', t1)
print('Время выполнения фрагмента с\nиспользованием списка:', t2)

Возможный вывод

S => qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
N => 100
ch => *
Время выполнения фрагмента без 
использования списка: 0.012363190999167273
Время выполнения фрагмента с 
использованием списка: 0.0018061999981000554

Казалось бы, что работа со списком будет выполняться медленнее, но замер скорости показал, что фрагмент со списком работает в 10 раз быстрее. При этом, объем памяти, занятой объектами второго фрагмента, в 2 раза меньше! Таким образом, фрагмет программы 2 будет эффективно работать как по скорости, так и по памяти.

Приложение

Примеры решения задач
Вопросы
Темы сообщений
Задания А
Задания Б
Задания С
Ссылки
1 Звезда2 Звезды3 Звезды4 Звезды5 Звезд (1 оценок, среднее: 5,00 из 5)
Загрузка...

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.


Обсуждение закрыто.