Как создать последовательность в python
Перейти к содержимому

Как создать последовательность в python

  • автор:

Типы последовательностей в Python

Единственная операция, которая реализована в неизменяемых типах последовательностей и которая не доступна изменяемым типам последовательностей — это поддержка встроенного метода hash() .

Эта поддержка позволяет использовать неизменяемые последовательности, такие как экземпляры кортежей, в качестве ключей словарей dict и хранить их в экземплярах множеств set и frozenset .

Изменяемые типы последовательностей:
  • list списки
  • bytearray байтовые массивы

Python по-разному обрабатывает изменяемые и неизменяемые объекты:

  • Доступ к неизменяемым последовательностям быстрее, чем к изменяемым.
  • Изменяемые объекты отлично подходят для использования, когда вам нужно изменить, добавить или удалить элементы последовательности.
  • Неизменяемые последовательности используются, когда вам нужно убедиться, что созданный вами объект всегда останется прежним.
  • Неизменяемые последовательности очень «дороги» для изменения, потому что для этого необходимо создать копию, а менять изменяемые последовательности «дешево».
  • КРАТКИЙ ОБЗОР МАТЕРИАЛА.
  • Утиная типизация ‘Duck Typing’
  • Что такое вызываемый объект callable?
  • Как проверить тип переменной/объекта
  • Логический тип данных bool
  • Целые числа int
  • Ограничение длины преобразования целочисленной строки
  • Вещественные числа float
  • Комплексные числа complex
  • Типы последовательностей
  • Список list
  • Кортеж tuple
  • Диапазон range
  • Текстовые строки str
  • Словарь dict
  • Множество set и frozenset
  • Итератор Iterator, протокол итератора
  • Генератор generator и выражение yield
  • Контекстный менеджер with
  • Байтовые строки bytes
  • Байтовый массив bytearray
  • Тип memoryview, буфер обмена
  • Файловый объект file object
  • Универсальный псевдоним GenericAlias
  • Объект объединения Union

Последовательности в Python: списки и кортежи

Звезда активнаЗвезда активнаЗвезда активнаЗвезда активнаЗвезда активна

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

Последовательности в Python — итерабельные объекты, к элементам которых есть эффективный доступ с использованием целочисленных индексов. Доступ может быть осуществлён через специальный метод __getitem__(self, key), также поддерживается метод __len__() для возвращения длины последовательности.

__getitem__(self, key) — #метод, где доступ по индексу (или ключу).

Списки в Python — это изменяемые последовательности. В большинстве случаев используются для хранения однотипных данных, но могут хранить в себе и данные разных типов. Представлены классом list. Оформляются списки в квадратные скобки [последовательность через запятую].

Пример последовательности списком в Python:

my_first_list = [3, 5, 1, 8, 7, 2, 9, 4] print(my_first_list)

Кортежи в Python — это неизменяемые последовательности, объединяют в одно несколько значений. Чаще всего используются для хранения разнотипных данных. Представлены классом tuple. Оформляются кортежи в круглые скобки (последовательность через запятую).

Пример простого кортежа в Python:

my_first_list = (3, 5, 1, 8, "string", 7, 2, 9, 4) print(my_first_list)

Операции со списками в Python 3.5

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

my_first_list = [3, 5, 1, 8, 7, 2, 9, 4] print(my_first_list) if 3 in my_first_list: #Есть ли цифра 3 в списке print("3 is in list") else: print("3 is not in list") len(my_first_list) #Длина последовательности print(len(my_first_list)) #Вывод на экран длины последовательности print(min(my_first_list)) #Вывод на экран минимального элемента последовательности print(max(my_first_list)) #Вывод на экран максимального элемента списка print(sum(my_first_list)) #Вывод на экран суммы всех элементов my_first_list.append(6) #Добавляем в конец списка цифру 6 print(my_first_list) #Вывод на экран списка с добавленной в конце цифры 6 my_first_list.remove(3) #Удаление цифры 3 из списка print(my_first_list) #Вывод на экран списка без цифры 3

Сортировка списков в Python 3.5

Сортировка изменяемых последовательностей (списков) происходит очень просто благодаря специальному встроенного метода sort() и его параметрам key (записывается в круглых скобках как key=функция, где именно по указанной функции и сортируется список) и reverse (значения True или False). Простой пример сортировки списков ниже:

my_first_list = [3, 5, 1, 8, 7, 2, 9, 4]#создание списка print(my_first_list) #вывод на экран созданного списка my_first_list.sort(reverse=True) #вывод списка с конца по убыванию при помощи reverse=True print(my_first_list) #вывод на экран отсортированного списка

Или вот такой способ отсортировать буквы в списке по алфавиту:

primer=["a","o","k","d","y","r","f"] primer.sort() print(primer)

Кстати, отсортировать список с конца (с большего значения к меньшему) или осуществить разворот списка можно также и при помощи метода Reverse:

my_first_list.reverse() print(my_first_list) #Снова выводим список с конца при помощи метода Reverse, но немного по-другому

Да, итерация с конца также возможна и при помощи отрицательных индексов.

Операции с кортежами в Python 3.5

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

Пример простого написания кортежа на Python:

kortegh=(15,5) print(kortegh) kortegh=15, print(kortegh)

Также можно проитерировать число в кортеже. Ниже на примере показана итерация числа 15 в кортеже:

kortegh_iter=tuple(range(15)) print(kortegh_iter)

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

print(list(zip((1, 3, 8), (5, 6), (7, 12, 15))))

Функция zip в кортежах Python

Функция zip объединяет в один кортеж несколько кортежей. А вот и простой пример применения данной функции:

first_kortezh = (1,2,3) second_kortezh = (4,5,6) third_kortezh = (7,8,9) z=zip(first_kortezh,second_kortezh,third_kortezh) print(first_kortezh) print(second_kortezh) print(third_kortezh) print(list(z)) #выведет на экран список объединённых кортежей print(zip) #покажет класс функции print(z) #покажет место в памяти данного объекта

Распаковка кортежей в Python 3

Распаковка кортежей происходит благодаря звёздочке. Распаковка последовательностей в данном случае — это соответствие левой части правой.

first, second, third=zip(*((1, 4, 7), (2, 5, 8), (3, 6, 9))) # print(first) print(second) print(third)

Числовые последовательности для цикла Python

Если вам нужно перебрать последовательность чисел, в этом вам поможет встроенная функция range() . Эта функция генерирует арифметические прогрессии:

>>> for i in range(5): . print(i) . 0 1 2 3 4 >>> 

В примере выше, указанный аргумент range() число 5 — конечная точка, никогда не является частью сгенерированной последовательности. Например, range(10) генерирует 10 значений, для элементов последовательности длиной 10, проще для понимания от 0 до 9. В классе range() можно менять диапазон, указывая начальное значение, отличное от 0 или указать другое приращение последовательности (задать «шаг»), даже отрицательное:

range(5, 10) 5, 6, 7, 8, 9 range(0, 10, 3) 0, 3, 6, 9 range(-10, -100, -30) -10, -40, -70 

Чтобы перебрать индексы последовательности, вы можете комбинировать range() ]f-range и len() следующим образом:

>>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): . print(i, a[i]) . 0 Mary 1 had 2 a 3 little 4 lamb >>> 

В большинстве таких случаев удобно использовать функцию enumerate() .

Странная вещь происходит, если вы просто распечатаете range(10) :

>>> print(range(10)) range(0, 10) >>> 

Во многих отношениях возвращаемый объект range() ведет себя так, как будто это список, но на самом деле range() не создает список. Это объект, который возвращает элементы желаемой последовательности, только тогда, когда вы выполняете итерацию, тем самым экономя оперативную память.

Мы говорим, что такой объект является итеративным, то есть пригодным для функций или конструкции, которые ожидают что-то, из чего они могут получать последовательные элементы до тех пор, пока они не закончатся. Выше мы видели, что оператор for является такой конструкцией, а примером функции принимающей итеративный объект, является sum() :

>>> sum(range(4)) # 0 + 1 + 2 + 3 6 >>> 

Позже мы увидим больше функций, которые возвращают итерируемые значения и принимают их как аргументы. И наконец, может быть, вам интересно, как получить список list() из диапазона range ?

>>> list(range(4)) [0, 1, 2, 3] >>> 
Примеры использования:
>>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 11)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> list(range(0, 30, 5)) [0, 5, 10, 15, 20, 25] >>> list(range(0, 10, 3)) [0, 3, 6, 9] >>> list(range(0, -10, -1)) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> list(range(0)) [] >>> list(range(1, 0)) [] 
  • ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
  • Проверка условий, конструкция if/elif/else
  • Конструкция if/else в одну строку
  • Имитация оператора switch/case
  • while, цикл по условию
  • Цикл for
  • Числовые последовательности для цикла Python
  • Практическое применение for/in/else циклов
  • Инструкции break, continue и блок else в циклах Python
  • Оператор pass
  • Конструкция match/case, сопоставление с образцом

Sequence (последовательность)

Последовательности могут быть как изменяемыми, так и неизменяемыми. Размерность и состав созданной однажды неизменяемой последовательности не может меняться, вместо этого обычно создаётся новая последовательность.

Последовательности поддерживают сравнение (обычно производится лексикографически).
Пользовательские последовательности подчиняются Протоколу последовательностей.

Примеры последовательностей в стандартной библиотеке:

Список (list) изменяемая
Кортеж (tuple) неизменяемая
Диапазон (range) неизменяемая
Строка (str, unicode) неизменяемая
Массив (array.array) изменяемая
Адресация элементов

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

Нумерация индексов начинается с 0 (нуля).

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

 my_tuple = (1, 2, 3) 
my_tuple[0] # 1
my_tuple[10] # IndexError
Сравнение последовательностей

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

+py3.0 При лексикографическом сравнении для строк используются номера кодовых точек Юникода.

 (1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]

'ABC' < 'C' < 'Pascal' < 'Python'

(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)

# Python 2
[1, 'two'] < ['two', 1] # True
# Python 3
[1, 'two']

На заметку

Сравнение различных типов внутри последовательности (при помощи > и <) поддерживается, если для типов определены методы сравнения. В противном случае возбуждается TypeError (до +py3.0 порядок был произвольным, типы сравнивались по имени — list < str < tuple и т.д.). Например, численные типы сравниваются по их численному значению, то есть как 0==0.00 .

Проход по элементам

Проход по элементам последовательности производится при помощи for in:

 for item in [1, 2, 3]: 
print(item)
Количество элементов

Количество элементов в последовательности можно получить, используя функцию len().

 len([1, 2, 3]) # 3
Слияние (конкатенация)

Конкатенация двух последовательностей производится при помощи + .

 a = [3, 2, 1] 
b = [4, 5, 6]
a + b # [3, 2, 1, 4, 5, 6]
Повторение

Повторение (множение) элементов последовательностей производится при помощи * .

 a = [1] * 5 
a # [1, 1, 1, 1, 1]
b = [1, 2] * 3
b # [1, 2, 1, 2, 1, 2]
Рекомендуемые методы

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

Базовые __contains__(), __iter__()
Для изменяемых последовательностей append(), count(), extend(), index(), insert(), pop(), remove(), reverse(), sort()
Для поддержки слияния и повторения __add__(), __iadd__(), __imul__(), __mul__(), __radd__(), __rmul__()

На заметку

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

Синонимы поиска: Sequence (последовательность), последовательность, последовательности

Статьи раздела
list (список) Список — изменяемая последовательность с упорядоченными элементами.
range (диапазон) Диапазон — неизменяемая последовательность целых чисел.
sequence.index Ищет указанное значение в последовательности.
str (строка) Строка — базовый тип представляющий из себя неизменяемую последовател…
tuple (кортеж) Кортеж — неизменяемая последовательность с упорядоченными элементами.
xrange Диапазон — неизменяемая последовательность целых чисел.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *