list.py

# Списки (в других языках - массивы)

# Примеры как записать последовательность в диапазоне при помощи range
# numbers = list(range(5))
# print(numbers)
#
# even_numbers = list(range(0, 10, 2))
# odd_numbers = list(range(1, 10, 2))
# print(even_numbers, odd_numbers)
#
#
# # Преобразование строки в список
# s = 'abcde'
# chars = list(s)
# print(chars)
#
# # Пример печати списка строк
# names = ['Michael', 'John', 'Freddie']
# print(names)


# Основы работы со списками

# len() - выводит количество элементов в списке
# numbers = [2, 4, 6, 8, 10]
# languages = ['Python', 'C#', 'C++', 'Java']
# print(len(numbers))      # выводим длину списка numbers
# print(len(languages))    # выводим длину списка languages
# print(len(['apple', 'banana', 'cherry']))   # выводим длину списка, состоящего из 3 элементов


# in - оператор принадлежности
# позволяет проверить, содержит ли список некоторый элемент.
# numbers = [2, 4, 6, 8, 10]
# if 2 in numbers:
#     print('Список numbers содержит число 2')
# else:
#     print('Список numbers не содержит число 2')

# in можно использовать вместе с логическим оператором not
# numbers = [2, 4, 6, 8, 10]
# if 0 not in numbers:
#     print('Список numbers не содержит нулей')


# Индексация -
# слева направо от 0 до n-1
# справа налево от -1 до -n


# Slice
# numbers = [2, 4, 6, 8, 10]
# numbers[x:y] - Slice from x (included) to y (not included) in numbers
# print(numbers[1:3])
# print(numbers[2:5])
# numbers[x:] - берет значения списка от x до конца списка
# numbers[:y] - берет значения от начала списка до y не включительно
# Срез numbers[:] возвращает копию исходного списка.
# fruits = ['apple', 'apricot', 'banana', 'cherry', 'kiwi', 'lemon', 'mango']
# fruits[2:5] = ['банан', 'вишня', 'киви']
# print(fruits)


# Конкатенация и умножение списков, примеры
# print([1, 2, 3, 4] + [5, 6, 7, 8])
# print([7, 8] * 3)
# print([0] * 10)

# Еще примеры
# a = [1, 2, 3, 4]
# b = [7, 8]
# a += b   # добавляем к списку a список b
# b *= 5   # повторяем список b 5 раз
# print(a)
# print(b)


# Встроенные функции sum(), min(), max()

# sum()
# numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# print('Сумма всех элементов списка =', sum(numbers))

# min() и max()
# numbers = [3, 4, 10, 3333, 12, -7, -5, 4]
# print('Минимальный элемент =', min(numbers))
# print('Максимальный элемент =', max(numbers))


# Методы добавления и удаления элементов append() и extend(), оператор del

# append() - добавление нового элемента в конец списка
# numbers = [1, 1, 2, 3, 5, 8, 13]  # создаем список
# numbers.append(21)  # добавляем число 21 в конец списка
# numbers.append(34)  # добавляем число 34 в конец списка
# print(numbers)

# extend() - расширяет один список элементами другого списка
# numbers = [0, 2, 4, 6, 8, 10]
# odds = [1, 3, 5, 7]
# numbers.extend(odds)
# print(numbers)

# Отличие между методами append() и extend() проявляется при добавлении строки к списку
# words1 = ['iq option', 'stepik', 'beegeek']
# words2 = ['iq option', 'stepik', 'beegeek']
# words1.append('python')
# words2.extend('python')
# print(words1)
# print(words2)

# del - удаляет элементы списка по индексу
# numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# del numbers[5]    # удаляем элемент имеющий индекс 5
# print(numbers)

# numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# del numbers[2:7]    # удаляем элементы с 2 по 6 включительно
# print(numbers)

# numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# del numbers[::2] # Все элементы на четных позициях
# print(numbers)

# colors = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'brown', 'magenta']
# del colors[2]
# del colors[6]
# print(colors)

# Как выводить данные из списка без квадратных скобок:

# Вариант 1
# numbers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
# for i in range(len(numbers)):
#     print(numbers[i])

# Вариант 2
# numbers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
# for num in numbers:
#     print(num)

# В Python есть удобный и простой способ вывода всех элементов списка:
# numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# print(*numbers)

# numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# print(*numbers, sep='\n')

# Аналогично можно распаковать строки по символам
# s = 'Python'
# print(*s)
# print()
# print(*s, sep='\n')



# split() - строковый метод, перегоняет строку в список
# разбивает строку на слова, используя в качестве
# разделителя последовательность пробельных символов.
# s = 'Python is the most powerful language'
# words = s.split()
# print(words)

# Если надо ввести ряд чисел и распознать их в списке как числа,
# то придется каждый элемент перевести из строки в число:
# numbers = input().split() # Например - 1 2 3 4 5
# numbers = input().split()
# for i in range(len(numbers)):
#     numbers[i] = int(numbers[i])

# У метода split() есть необязательный параметр, который определяет,
# какой набор символов будет использоваться в качестве разделителя
# между элементами списка. Например, вызов метода split('.')
# вернет список, полученный разделением исходной строки по символу '.'
# ip = '192.168.1.24'
# numbers = ip.split('.')    # указываем явно разделитель
# print(numbers)



# join() - строковый метод, перегоняет список в строку
# собирает строку из элементов списка, используя в качестве разделителя строку,
# к которой применяется метод
# words = ['Python', 'is', 'the', 'most', 'powerful', 'language']
# s = ' '.join(words)
# print(s)

# Еще несколько примеров join
# words = ['Мы', 'учим', 'язык', 'Python']
# print('*'.join(words))
# print('-'.join(words))
# print('?'.join(words))
# print('!'.join(words))
# print('*****'.join(words))
# print('abc'.join(words))
# print('123'.join(words))

# Существует большая разница между результатами вызова методов
# s.split() и s.split(' ').
# Разница в поведении проявляется когда строка содержит несколько пробелов между словами
# s = 'Python    is   the  most  powerful  language'
# words1 = s.split()
# words2 = s.split(' ')
# print(words1)
# print(words2)



# МЕТОДЫ СПИСКОВ
# Метод insert()
# Метод index()
# Метод remove()
# Метод pop()
# Метод reverse()
# Метод count()
# Метод clear()
# Метод sort()

# insert()
# позволяет вставлять значение в список в заданной позиции.
# В него передается два аргумента
# index - индекс, задающий место вставки значения
# value - значение, которое требуется вставить
# names = ['Gvido', 'Roman' , 'Timur']
# print(names)
# names.insert(0, 'Anders')
# print(names)
# names.insert(3, 'Josef')
# print(names)
# Если указан недопустимый индекс, то во время выполнения программы не происходит ошибки.
# Если задан индекс за пределами конца списка, то значение будет добавлено в конец списка.
# Если применен отрицательный индекс, который указывает на недопустимую позицию,
# то значение будет вставлено в начало списка


# index()
# возвращает индекс первого элемента, значение которого равняется переданному в метод значению
# value - значение, индекс которого требуется найти
# Если элемент в списке не найден, то во время выполнения происходит ошибка
# names = ['Gvido', 'Roman', 'Timur']
# position = names.index('Timur')
# print(position)

# Следующий программный код приводит к ошибке
# names = ['Gvido', 'Roman' , 'Timur']
# position = names.index('Anders')
# print(position)

# Чтобы избежать таких ошибок, можно использовать метод index()
# вместе с оператором принадлежности in
# names = ['Gvido', 'Roman' , 'Timur']
# if 'Anders' in names:
#     position = names.index('Anders')
#     print(position)
# else:
#     print('Такого значения нет в списке')


# remove()
# удаляет первый элемент, значение которого равняется переданному в метод значению
# value - значение, которое требуется удалить
# Метод уменьшает размер списка на один элемент.
# Все элементы после удаленного элемента смещаются на одну позицию к началу списка.
# Если элемент в списке не найден, то во время выполнения происходит ошибка
# food = ['Рис', 'Курица', 'Рыба', 'Брокколи', 'Рис']
# print(food)
# food.remove('Рис')
# print(food)
# метод remove() удаляет только первый элемент с указанным значением.
# Все последующие его вхождения остаются в списке.
# Чтобы удалить все вхождения нужно использовать цикл while
# в связке с оператором принадлежности in и методом remove


# pop()
# удаляет элемент по указанному индексу и возвращает его.
# В метод pop() передается один необязательный аргумент
# index - индекс элемента, который требуется удалить
# Если индекс не указан, то метод удаляет и возвращает последний элемент списка.
# Если список пуст или указан индекс за пределами диапазона,
# то во время выполнения происходит ошибка
# names = ['Gvido', 'Roman', 'Timur']
# item = names.pop(1)
# print(item)
# print(names)


# count()
# возвращает количество элементов в списке,
# значения которых равны переданному в метод значению
# value - значение, количество элементов, равных которому, нужно посчитать
# Если значение в списке не найдено, то метод возвращает 0
# names = ['Timur', 'Gvido', 'Roman', 'Timur', 'Anders', 'Timur']
# cnt1 = names.count('Timur')
# cnt2 = names.count('Gvido')
# cnt3 = names.count('Josef')
# print(cnt1)
# print(cnt2)
# print(cnt3)


# reverse()
# инвертирует порядок следования значений в списке, то есть меняет его на противоположный
# names = ['Gvido', 'Roman', 'Timur']
# names.reverse()
# print(names)
# Существует большая разница между вызовом метода names.reverse() и использованием среза names[::-1].
# Метод reverse() меняет порядок элементов на обратный в текущем списке, а срез создает копию списка,
# в котором элементы следуют в обратном порядке


# clear()
# удаляет все элементы из списка
# names = ['Gvido', 'Roman' , 'Timur']
# names.clear()
# print(names)


# РАЗНИЦА СТРОКОВЫХ И СПИСОЧНЫХ МЕТОДОВ
# Существует большая разница в работе строковых и списочных методов.
# Строковые методы не изменяют содержимого объекта к которому они применяются,
# а возвращают новое значение. Списочные методы, напротив, меняют содержимое объекта
# к которому применяются.



# sort()
# сортирует элементы списка по возрастанию или убыванию
# a = [1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6,  8, -2, 99]
# a.sort()
# print('Отсортированный список:', a)
# По умолчанию метод sort() сортирует список по возрастанию.
# Если требуется отсортировать список по убыванию,
# необходимо явно указать параметр reverse = True
# a = [1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6,  8, -2, 99]
# a.sort(reverse = True)   # сортируем по убыванию
# print('Отсортированный список:', a)

# Вместо sort() можно использовать sorted() что уменьше количество строк:
# Этот код:
# a = [1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6,  8, -2, 99]
# a.sort()
# print('Отсортированный список:', a)
# можно записать так:
# print('Отсортированный список:', sorted([1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6,  8, -2, 99]))

# С помощью метода sort() можно сортировать списки содержащие не только числа, но и строки.
# В таком случае элементы списка сортируются в соответствии с лексикографическим порядком:
# https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BA%D1%81%D0%B8%D0%BA%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA
# Метод сортировки используемый этим методом https://ru.wikipedia.org/wiki/Timsort



# Списочные выражения

# Для того, чтобы создать список состоящий из 1010 нулей мы можем использовать следующий код:
# zeros = []
# for i in range(10):
#     zeros.append(0)
# В Python, однако есть более простой и компактный способ для создания такого списка.
# Мы можем использовать оператор умножения списка на число
# zeros = [0] * 10
# Для создания списков, заполненных по более сложным правилам нам приходится явно использовать цикл for.
# Например, для создания списка целых чисел от 00 до 99, мы вынуждены писать такой код
# numbers = []
# for i in range(10):
#     numbers.append(i)
# Такой код хоть и не является сложным, однако достаточно громоздок.

# В Python есть механизм для создания списков из неповторяющихся элементов.
# Такой механизм называется — списочное выражение (list comprehension).
# numbers = [i for i in range(10)]
# [выражение for переменная in последовательность]

# Создать список, заполненный 10 нулями можно и при помощи списочного выражения
# zeros = [0 for i in range(10)]
# print(zeros)

# Создать список, заполненный квадратами целых чисел от 0 до 9 можно так
# squares = [i ** 2 for i in range(10)]
# print(squares)

# Создать список, заполненный кубами целых чисел от 10 до 20 можно так
# cubes = [i ** 3 for i in range(10, 21)]
# print(cubes)

# Создать список, заполненный символами строки
# chars = [c for c in 'abcdefg']
# print(chars)

# если сначала вводится число n – количество строк, а затем сами строки,
# то создать список можно так
# n = int(input())
# lines = [input() for _ in range(n)]
# Можно опустить описание переменной n
# lines = [input() for _ in range(int(input()))]
# Если требуется считать список чисел, то необходимо добавить преобразование типов
# numbers = [int(input()) for _ in range(int(input()))]
# Списочные выражения часто используются для инициализации списков.
# В Python не принято создавать пустые списки, а затем заполнять их значениями,
# если можно этого избежать.

# В списочных выражениях можно использовать условный оператор.
# Например, если требуется создать список четных чисел от 0 до 20,
# то мы можем написать такой код
# evens = [i for i in range(21) if i % 2 == 0]
# Важно: для того, чтобы получить список, состоящий из четных чисел,
# лучше использовать функцию range(0, 21, 2).
# Предыдущий пример приведен для демонстрации возможности использования условий в списочных выражениях.

# В списочном выражении можно использовать вложенные циклы
# numbers = [i * j for i in range(1, 5) for j in range(2)]
# print(numbers)
# Такой код равнозначен следующему
# numbers = []
# for i in range(1, 5):
#     for j in range(2):
#         numbers.append(i * j)
# print(numbers)



# СОРТИРОВКА СПИСКОВ
# Алгоритм сортировки — это алгоритм упорядочивания элементов в списке.
# Алгоритмы сортировки оцениваются по скорости выполнения и эффективности использования памяти:
# время — основной параметр, характеризующий быстродействие алгоритма;
# память — ряд алгоритмов требует выделения дополнительной памяти под временное хранение данных.
# Алгоритмы сортировки, не потребляющие дополнительной памяти, относят к сортировкам на месте.
#
# Основные алгоритмы сортировки
# Медленные:
# Пузырьковая сортировка (Bubble sort);
# Сортировка выбором (Selection sort);
# Сортировка простыми вставками (Insertion sort).
#
# Быстрые:
# Сортировка Шелла (Shell sort);
# Быстрая сортировка (Quick sort);
# Сортировка слиянием (Merge sort);
# Пирамидальная сортировка (Heap sort);
# Сортировка TimSort (используется в Java и Python).
#
# К алгоритмам не основанным на сравнениях можно отнести следующие:
# Сортировка подсчетом (Counting sort);
# Блочная сортировка (Bucket sort);
# Поразрядная сортировка (Radix sort).