Последовательности в Python — типы и функции
В этом уроке вы узнаете о последовательностях Python и их основных типах, функциях и операциях.
- Что такое последовательности в Python?
- Тип последовательности и итерируемый тип
- 1) Подсчет элементов последовательности Python
- 2) Проверка наличия элемента
- 3) Поиск индекса элемента в последовательности Python
- 4) Нарезка
- 5) Получение минимальных и максимальных элементов из последовательности Python
- 6) Объединение двух последовательностей Python
- 7) Повторение последовательности Python
Что такое последовательности в Python?
Последовательность в Python — это позиционно упорядоченный набор элементов. И вы можете ссылаться на любой элемент последовательности, используя его порядковый номер, например, s[0] и s[1].
В Python индекс последовательности начинается с 0, а не с 1. Таким образом, первый элемент — это s[0], а второй элемент — s[1]. Если последовательность s имеет n элементов, последний элемент — s[n-1].
Python имеет следующие встроенные типы последовательностей: списки, байтовые массивы, строки, кортежи, диапазоны и байты. Python классифицирует типы последовательностей как изменяемые и неизменяемые. Изменяемыми типами последовательностей являются списки и байтовые массивы, а неизменяемыми типами последовательностей являются строки, кортежи, диапазоны и байты.
Последовательность может быть гомогенной или гетерогенной. В однородной последовательности все элементы имеют один и тот же тип. Например, строки представляют собой однородные последовательности, в которых каждый элемент имеет один и тот же тип.
Однако списки представляют собой разнородные последовательности, в которых вы можете хранить элементы разных типов, включая целые числа, строки, объекты и т. д.
В целом, однородные типы последовательностей более эффективны, чем гетерогенные, с точки зрения хранения и операций.
Тип последовательности и итерируемый тип
Итерация — это коллекция объектов, из которой вы можете получить каждый элемент один за другим. Следовательно, любая последовательность является итерируемой. Например, список является итеративным.
Однако итерируемый объект не может быть типом последовательности. Например, набор является итеративным, но не является последовательностью.
Ниже объясняются некоторые стандартные методы последовательности:
1) Подсчет элементов последовательности Python
Чтобы получить количество элементов последовательности, вы используете встроенную функцию len:
len(seq)
В следующем примере функция len используется для получения количества элементов в списке городов:
cities = ['San Francisco', 'New York', 'Washington DC'] print(len(cities))
Выход:
3
2) Проверка наличия элемента
Чтобы проверить, существует ли элемент в последовательности, вы используете оператор in:
element in seq
В следующем примере оператор in используется для проверки наличия города «New York» в списке городов:
cities = ['San Francisco', 'New York', 'Washington DC']
print('New York' in cities)
Выход:
True
Чтобы отрицать оператор in, вы используете оператор not. В следующем примере проверяется, нет ли «New York» в списке городов:
cities = ['San Francisco', 'New York', 'Washington DC']
print('New York' not in cities)
Выход:
False
3) Поиск индекса элемента в последовательности Python
seq.index(e) возвращает индекс первого вхождения элемента e в последовательности seq:
seq.index(e)
Например:
numbers = [1, 4, 5, 3, 5, 7, 8, 5] print(numbers.index(5))
Выход:
2
Индекс первого вхождения числа 5 в список чисел равен 2. Если числа нет в последовательности, вы получите сообщение об ошибке:
numbers = [1, 4, 5, 3, 5, 7, 8, 5] print(numbers.index(10))
Ошибка:
ValueError: 10 is not in list
Чтобы найти индекс первого вхождения элемента в определенный индекс или после него, вы используете следующую форму индексного метода:
seq.index(e, i)
Следующий пример возвращает индекс первого вхождения числа 5 после третьего индекса:
numbers = [1, 4, 5, 3, 5, 7, 8, 5] print(numbers.index(5, 3))
Выход:
4
Следующая форма метода index позволяет найти индекс первого вхождения элемента в индексе i или после него и до индекса j:
seq.index(e, i, j)
Например:
numbers = [1, 4, 5, 3, 5, 7, 8, 5] print(numbers.index(5, 3, 5))
Выход:
4
4) Нарезка
Чтобы получить срез от индекса i до j(но не включая его), вы используете следующий синтаксис:
seq[i:j]
Например:
numbers = [1, 4, 5, 3, 5, 7, 8, 5] print(numbers[2:6])
Выход:
[5, 3, 5, 7]
Когда вы нарезаете последовательность, легче представить, что индексы последовательности располагаются между двумя элементами, например:
Расширенный срез позволяет получить срез от i до(но не включая j) с шагом k:
seq[i:j:k]
Например:
numbers = [1, 4, 5, 3, 5, 7, 8, 5] print(numbers[2:6:2])
Выход:
[5, 5]
5) Получение минимальных и максимальных элементов из последовательности Python
Если порядок элементов в последовательности указан, вы можете использовать встроенные функции min и max для поиска минимального и максимального элементов:
numbers = [1, 4, 5, 3, 5, 7, 8, 5] print(min(numbers)) # 1 print(max(numbers)) # 8
Выход:
1 8
6) Объединение двух последовательностей Python
Чтобы объединить две последовательности в одну, используйте оператор +:
s3 = s1 + s2
В следующем примере объединяются две последовательности строк:
east = ['New York', 'New Jersey'] west = ['San Diego', 'San Francisco'] cities = east + west print(cities)
Выход:
['New York', 'New Jersey', 'San Diego', 'San Francisco']
Объединять неизменяемые последовательности вполне безопасно. В следующем примере к западному списку добавляется один элемент. И это не влияет на последовательность городов:
west.append('Sacramento')
print(west)
print(cities)
Выход:
['San Diego', 'San Francisco', 'Sacramento'] ['New York', 'New Jersey', 'San Diego', 'San Francisco']
Однако вы должны знать о конкатенациях изменяемых последовательностей. В следующем примере показано, как объединить список сам с собой:
city = [['San Francisco', 900_000]] cities = city + city print(cities)
Выход:
[['San Francisco', 1000000], ['San Francisco', 1000000]]
Поскольку список изменчив, адреса памяти первого и второго элементов списка городов одинаковы:
print(id(cities[0]) == id(cities[1])) # True
Кроме того, при изменении значения из исходного списка изменяется и объединенный список:
city[0][1] = 1_000_000 print(cities)
Собираем все вместе:
city = [['San Francisco', 900_000]] cities = city + city print(cities) print(id(cities[0]) == id(cities[1])) # True city[0][1] = 1_000_000 print(cities)
Выход:
[['San Francisco', 900000], ['San Francisco', 900000]] True [['San Francisco', 1000000], ['San Francisco', 1000000]]
7) Повторение последовательности Python
Чтобы повторить последовательность несколько раз, используйте оператор умножения(*). В следующем примере строка Python повторяется три раза:
s = 'ha' print(s*3)
Выход:
hahaha