Списки, кортежи и словари

Линейный поиск

Линейный поиск — это один из самых простых и понятных алгоритмов поиска. Мы можем думать о нем как о расширенной версии нашей собственной реализации оператора в Python.

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

def LinearSearch(lys, element):
    for i in range (len(lys)):
        if lys == element:
            return i
    return -1

Итак, если мы используем функцию для вычисления:

>>> print(LinearSearch(, 2))

То получим следующий результат:

1

Это индекс первого вхождения искомого элемента, учитывая, что нумерация элементов в Python начинается с нуля.

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

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

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

Списки как очереди

Очередь представляет собой контейнер объектов, которые вставляются и удаляются в соответствии с принципом first-in first-out (FIFO). В очереди только две операции разрешены enqueue и dequeue. Enqueue (append()) означает вставить элемент в конец очереди, dequeue (pop (0)) означает удаление переднего элемента.

Пример:

Python

queue =
print(«Before enqueue «, queue)
queue.append(4)
queue.append(5)
print(«After enqueue «, queue)
queue.pop(0)
print(«After dequeue «, queue)
queue.pop(0)
queue.pop(0)
print(«After dequeue «, queue)

Вывод:

Python

Before enqueue deque()
After enqueue deque()
After dequeue deque()
After dequeue deque()

Большие объемы табличных данных – массивы

Python со временем стал широко использоваться в области Data Science для обработки, анализа и моделирования данных. Одной из причин быстро растущей популярности является разработка различных пакетов с открытым исходным кодом

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

Например, если вам нужно обрабатывать большое количество числовых данных, можно подумать об использовании массивов NumPy, которые являются основным типом данных, реализованном в пакете NumPy

Если вам нужно работать со структурированными данными, где типы данных смешаны (например, строки, даты и числа), вы можете обратить внимание на DataFrame из Pandas, которые также являются основным типом данных для пакета Pandas. Если вы занимаетесь машинным обучением, вам определенно стоит углубиться в тензоры, которые считаются наиболее важными типами данных в популярных фреймворках машинного обучения, таких как TensorFlow и PyTorch

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

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

2. Как лучше выбирать элементы из списка?

Если вы хотите продуктивно работать со списками, то должны уметь получать доступ к данным, хранящимся в них.

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

# Выбираем первый элемент списка
oneZooAnimal = biggerZoo

# Выводим на экран переменную `oneZooAnimal`
print(oneZooAnimal)

Запустите данный код и убедитесь, что вы получите первый элемент списка, сохраненного в переменную . Это может быть поначалу несколько непривычно, но нумерация начинается с числа , а не .

Как получить последний элемент списка?

Ответ на этот вопрос является дополнением к объяснению в предыдущем разделе.

Попробуйте ввести отрицательное значение, например, или , в оператор индекса, чтобы получить последние элементы нашего списка !

# Вставляем -1 
monkeys = biggerZoo
print(monkeys)

# А теперь -2
zebra = biggerZoo
print(zebra)

Не правда ли, не слишком сложно?

Что означает ошибка «Index Out Of Range»?

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

Лучший способ понять эту ошибку — попробовать ее получить самостоятельно.

Возьмите ваш список и передайте в оператор индекса либо очень маленькое отрицательное число, либо очень большое положительное число.

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

Срезы в списках

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

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

# Используем нотацию срезов
someZooAnimals = biggerZoo

# Выводим на экран то, что мы выбрали
print(someZooAnimals)

# Теперь поменяем местами 2 и двоеточие
otherZooAnimals = biggerZoo

# Выводим на экран полученный результат
print(otherZooAnimals)

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

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

В общем, подводя итоги:

# элементы берутся от start до end (но элемент под номером end не входит в диапазон!)
a

# элементы берутся начиная со start и до конца
a    

# элементы берутся с начала до end (но элемент под номером end не входит в диапазон!)
a

Совет: передавая в оператор индекса только двоеточие, мы создаем копию списка.

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

# Начиная со start, не доходя до end, с шагом step
a

Так что же по сути дает значение шага?

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

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

Также всегда помните, что ваш результат не включает индекс конечного значения, который вы указали в записи среза!

Как случайным образом выбрать элемент из списка?

Для этого мы используем пакет .

# Импортируем функцию `choice` из библиотеки `random` 
from random import choice

# Создадим список из первых четырех букв алфавита
list = 

# Выведем на экран случайный элемент списка
print(choice(list))

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

# Импортируем функцию `randrange` из библиотеки `random`
from random import randrange

# Создадим список из первых четырех букв алфавита
randomLetters = 

# Выбираем случайный индекс нашего списка
randomIndex = randrange(0,len(randomLetters))

# Выводим случайный элемент на экран
print(randomLetters)

Совет: обратите внимание на библиотеку , она может вам пригодиться во многих случаях при программировании на Python

sort(ключ, реверс)

Эта функция используется для сортировки элементов. Элементы списка должны реализовывать функцию __lt __ (self, other).

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

reverse принимает логическое значение. Если True, то список сортируется в обратном порядке. Значение по умолчанию Reverse — False, и элементы сортируются в естественном порядке.

>>> list_num = 
>>> list_num.sort()
>>> list_num

>>> list_num.sort(reverse=True)
>>> list_num

>>> 

Классификация коллекций

Примечание для словаря (dict):

• сам словарь изменяем — можно добавлять/удалять новые пары ключ: значение;
• значения элементов словаря — изменяемые и не уникальные;
• а вот ключи — не изменяемые и уникальные, поэтому, например, мы не можем сделать ключом словаря список, но можем кортеж. Из уникальности ключей, так же следует уникальность элементов словаря — пар ключ: значение.
  UPD: от sakutylev: Для того, чтобы объект мог быть ключом словаря, он должен быть хешируем. У кортежа, возможен случай, когда его элемент является не хешируемым объектом, и соответственно сам кортеж тогда тоже не является хешируемым и не может выступать ключом словаря.
• UPD: Благодарю morff за внимательность — {} без значений создают словарь, а со значениями, в зависимости от синтаксиса могут создавать как множество, так и словарь:

Разделение строки с использованием разделителя

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

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

print("Python2, Python3, Python, Numpy".split(','))
print("Python2; Python3; Python; Numpy".split(';'))

Результат:

Как видите, в результирующих списках
отсутствуют сами разделители.

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

import re

sep = re.split(',', 'Python2, Python3, Python, Numpy')
print(sep)
sep = re.split('(,)', 'Python2, Python3, Python, Numpy')
print(sep)

Результат:

Если вы хотите, чтобы разделитель был частью каждой подстроки в списке, можно обойтись без регулярных выражений и использовать list comprehensions:

text = 'Python2, Python3, Python, Numpy'
sep = ','

result = 
print(result)

Результат:

Классификация люстр и критерии выбора

Методы списков

len()

Метод возвращает длину объекта (списка, строки, кортежа или словаря).

принимает один аргумент, который может быть или последовательностью (например, строка, байты, кортеж, список, диапазон), или коллекцией (например, словарь, множество, frozenset).

list1 =   # список
print(len(list1)) # в списке 3 элемента, в выводе команды будет "3"

str1 = 'basketball'  # строка
print(len(str1))  # в строке 9 букв, в выводе команды будет "9"

tuple1 = (2, 3, 4, 5)  # кортеж
print(len(tuple1))  # в кортеже 4 элемента, в выводе команды будет "4"

dict1 = {'name': 'John', 'age': 4, 'score': 45} # словарь
print(len(dict1))  # в словаре 3 пары ключ-значение, в выводе команды будет "3"

index()

возвращает индекс элемента. Сам элемент передается методу в качестве аргумента. Возвращается индекс первого вхождения этого элемента (т. е., если в списке два одинаковых элемента, вернется индекс первого).

numbers = 
words = 

print(numbers.index(9)) # 4
print(numbers.index(2)) # 1
print(words.index("I")) # 0
print(words.index("JavaScript")) # возвращает ValueError, поскольку 'JavaScript' в списке 'words' нет

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

Цифра «2» встречается в списке дважды,
первое ее вхождение имеет индекс 1,
второе — 2. Метод index() возвращает индекс
1.

Аналогично возвращается индекс 0 для элемента «I».

Если элемент, переданный в качестве аргумента, вообще не встречается в списке, вернется ValueError. Так получилось с попыткой выяснить индекс «JavaScript» в списке .

Опциональные аргументы

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

words = 
print(words.index("am", 2, 5)) # 4

Метод index() будет искать элемент «am» в диапазоне от элемента с индексом 2 (включительно) до элемента с индексом 5 (этот последний элемент не входит в диапазон).

При этом возвращаемый индекс — индекс
элемента в целом списке, а не в указанном
диапазоне.

pop()

Метод удаляет и возвращает последний элемент списка.

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

Если в списке нет указанного вами индекса, метод выбросит exception .

cities = 

print "City popped is: ", cities.pop() # City popped is: San Francisco
print "City at index 2 is  : ", cities.pop(2) # City at index 2 is: San Antonio

Базовый функционал стека

Для реализации базового функционала
стека в программах на Python часто
используется связка метода pop() и метода
append():

stack = []

for i in range(5):
    stack.append(i)

while len(stack):
    print(stack.pop())

Где находится автозамена в ворде

Списки

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

Python

my_list = []
my_list = list()

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

Python

my_list =
my_list2 =
my_list3 =

Первый список содержит 3 числа, второй 3 строки, третий содержит смесь. Вы также можете создавать списки списков, вот так:

Python

my_nested_list =
print(my_nested_list) # , ]

В какой-то момент вам может понадобиться скомбинировать два списка вместе. Первый способ сделать это – при помощи метода extend:

Python

combo_list =
one_list =
a = combo_list.extend(one_list)

print(a) #

Немного проще будет просто добавить два списка вместе.

Python

my_list =
my_list2 =

combo_list = my_list + my_list2
print(combo_list) #

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

Python

alpha_list =
alpha_list.sort()

print(alpha_list) #

Получилось. Видите? Давайте взглянем на еще один пример, чтобы закрепить результат:

Python

alpha_list =
sorted_list = alpha_list.sort()

print(sorted_list) # None

В этом примере мы попытались назначить сортированный список переменной. Однако, когда вы вызываете метод sort() в списке, он сортирует список на месте. Так что если вы попробуете назначить результат другой переменной, тогда возникнет объект None, который аналогичен объекту Null в других языках. Таким образом, когда вам нужно отсортировать что-нибудь, просто помните, что вы сортируете на месте, и вы не можете назначить объект другой переменной.
Вы можете разрезать список также, как вы делаете это со строкой:

Python

a = alpha_list
print(a) #

Данный код выдает список из трех первых элементов.

Задания для самопроверки

1. Дан список . Необходимо изменить его, увеличив каждое значение на 7.2.

2. Пользователь
вводит с клавиатуры N значений (строки или числа). На их основе
сформировать список, состоящий из продублированных элементов. (Например, из
значений 1, 5, «abc» формируется список ).

3. Написать
программу сложения двух матриц:

4. Пользователь
вводит N значений в
список. Необходимо проверить: было ли введено число 5.

Видео по теме

Python 3 #1: установка и запуск интерпретатора языка

Python 3 #2: переменные, оператор присваивания, типы данных

Python 3 #3: функции input и print ввода/вывода

Python 3 #4: арифметические операторы: сложение, вычитание, умножение, деление, степень

Python 3 #5: условный оператор if, составные условия с and, or, not

Python 3 #6: операторы циклов while и for, операторы break и continue

Python 3 #7: строки — сравнения, срезы строк, базовые функции str, len, ord, in

Python 3 #8: методы строк — upper, split, join, find, strip, isalpha, isdigit и другие

Python 3 #9: списки list и функции len, min, max, sum, sorted

Python 3 #10: списки — срезы и методы: append, insert, pop, sort, index, count, reverse, clear

Python 3 #11: списки — инструмент list comprehensions, сортировка методом выбора

Python 3 #12: словарь, методы словарей: len, clear, get, setdefault, pop

Python 3 #13: кортежи (tuple) и операции с ними: len, del, count, index

Python 3 #14: функции (def) — объявление и вызов

Python 3 #15: делаем «Сапер», проектирование программ «сверху-вниз»

Python 3 #16: рекурсивные и лямбда-функции, функции с произвольным числом аргументов

Python 3 #17: алгоритм Евклида, принцип тестирования программ

Python 3 #18: области видимости переменных — global, nonlocal

Python 3 #19: множества (set) и операции над ними: вычитание, пересечение, объединение, сравнение

Python 3 #20: итераторы, выражения-генераторы, функции-генераторы, оператор yield

Python 3 #21: функции map, filter, zip

Python 3 #22: сортировка sort() и sorted(), сортировка по ключам

Python 3 #23: обработка исключений: try, except, finally, else

Python 3 #24: файлы — чтение и запись: open, read, write, seek, readline, dump, load, pickle

Python 3 #25: форматирование строк: метод format и F-строки

Python 3 #26: создание и импорт модулей — import, from, as, dir, reload

Python 3 #27: пакеты (package) — создание, импорт, установка (менеджер pip)

Python 3 #28: декораторы функций и замыкания

Python 3 #29: установка и порядок работы в PyCharm

Python 3 #30: функция enumerate, примеры использования

Создание списков на Python

• Создать список можно несколькими способами. Рассмотрим их.

1. Получение списка через присваивание конкретных значений

Так выглядит в коде Python пустой список:

s =   # Пустой список

Примеры создания списков со значениями:

l = 25, 755, -40, 57, -41   # список целых чисел
l = 1.13, 5.34, 12.63, 4.6, 34.0, 12.8   # список из дробных чисел
l = "Sveta", "Sergei", "Ivan", "Dasha"   # список из строк
l = "Москва", "Иванов", 12, 124   # смешанный список
l = , , , 1, , 1, 1, 1,    # список, состоящий из списков
l = 's', 'p', 'isok', 2 # список из значений и списка

2. Списки при помощи функции List()

Получаем список при помощи функции List()

empty_list = list() # пустой список
l = list ('spisok')  # 'spisok' - строка
print(l) # - результат - список

4. Генераторы списков

• В python создать список можно также при помощи генераторов, — это довольно-таки новый метод:
• Первый простой способ.

Сложение одинаковых списков заменяется умножением:

# список из 10 элементов, заполненный единицами
l = 1*10
# список l = 

Второй способ сложнее.

l = i for i in range(10)
# список l = 

или такой пример:

c = c * 3 for c in 'list'
print (c) # 

Пример:
Заполнить список квадратами чисел от 0 до 9, используя генератор списка.

Решение: 

l = i*i for i in range(10)

еще пример:

l = (i+1)+i for i in range(10)
print(l) # 

Случайные числа в списке:

from random import randint 
l = randint(10,80) for x in range(10)
# 10 чисел, сгенерированных случайным образом в диапазоне (10,80)

Задание Python 4_1:
Создайте список целых чисел от -20 до 30 (генерация).

Результат:

Задание Python 4_2:
Создайте список целых чисел от -10 до 10 с шагом 2 (генерация list).

Результат:

Задание Python 4_3:
Создайте список из 20 пятерок (генерация).

Результат:

Задание Python 4_4:
Создайте список из сумм троек чисел от 0 до 10, используя генератор списка (0 + 1 + 2, 1 + 2 + 3, …).

Результат:

Задание Python 4_5 (сложное):
Заполните массив элементами арифметической прогрессии. Её первый элемент, разность и количество элементов нужно ввести с клавиатуры.
  
* Формула для получения n-го члена прогрессии: a_n = a₁ + (n-1) * d

Простейшие операции над списками

• Списки можно складывать (конкатенировать) с помощью знака «+»:

l = 1, 3 + 4, 23 + 5
 
# Результат:
# l = 

33, -12, 'may' + 21, 48.5, 33 # 

или так:

a=33, -12, 'may'
b=21, 48.5, 33
print(a+b)# 

Операция повторения:

,,,1,1,1 * 2 # , , , , , ]

Пример:
Для списков операция переприсваивания значения отдельного элемента списка разрешена!:

a=3, 2, 1
a1=;
print(a) # 

Можно!

Задание 4_6:
В строке записана сумма натуральных чисел: ‘1+25+3’. Вычислите это выражение. Работать со строкой, как со списком.

Начало программы:

s=input('введите строку')
l=list(str(s));

Как узнать длину списка?

3 Общие методы для части коллекций

Объяснение работы методов и примеры:

• .count() — метод подсчета определенных элементов для неуникальных коллекций (строка, список, кортеж), возвращает сколько раз элемент встречается в коллекции.
• .index() — возвращает минимальный индекс переданного элемента для индексированных коллекций (строка, список, кортеж)
• .copy() — метод возвращает неглубокую (не рекурсивную) копию коллекции (список, словарь, оба типа множества).
• .clear() — метод изменяемых коллекций (список, словарь, множество), удаляющий из коллекции все элементы и превращающий её в пустую коллекцию.

Особые методы сравнения множеств (set, frozenset)

• set_a.isdisjoint(set_b) — истина, если set_a и set_b не имеют общих элементов.
• set_b.issubset(set_a) — если все элементы множества set_b принадлежат множеству set_a, то множество set_b целиком входит в множество set_a и является его подмножеством (set_b — подмножество)
• set_a.issuperset(set_b) — соответственно, если условие выше справедливо, то set_a — надмножество

Прохождение по списку

enumerate(iterable )

Возвращает генератор, отдающий пары счётчик(индекс)-элемент для указанного итерируемого объекта.

Параметры:

— последовательность, итератор или объекты, поддерживающие итерирование.

– значение, с которого начинается отсчет. Необязательный аргумент, по умолчанию равен нулю.

Возвращаемое значение:

enumerate object — генератор, отдающий пары счётчик(индекс)-элемент для указанного итерируемого объекта.

Примечание:

Вы можете преобразовать enumerate object в список или кортеж, используя функции и соответственно.

Примеры:

Пример 1: Работа с  .

grocery = 
enumerateGrocery = enumerate(grocery)

# <class 'enumerate'>
print(type(enumerateGrocery))

# 
print(list(enumerateGrocery))

enumerateGrocery = enumerate(grocery, 10)

# 
print(list(enumerateGrocery))

Пример 2: Прохождение по enumerate object.

grocery = 

for item in enumerate(grocery):
    print(item)

print('\n')
for count, item in enumerate(grocery):
    print(count, item)

print('\n')
# изменение значения start
for count, item in enumerate(grocery, 100):
    print(count, item)

Результат:(0, ‘bread’)(1, ‘milk’)(2, ‘butter’)

0 bread1 milk2 butter

100 bread101 milk102 butter

Генераторы с условием if… else …

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

Данный генератор эквивалентен следующему коду:

Конструкции и могут быть использованы вместе в одном генераторе:

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

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

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

Работа этого генератора может быть выполнена следующим кодом:

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

В Python версии \(3.8\) появился оператор который позволяет выполнять одинаковые операции только в одном месте, благодаря чему приведенный выше генератор может быть записан как:

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

В данном случае так же целесообразнее воспользоваться оператором

Если вы используете Python версии ниже \(3.8\), то что бы избежать двойного выполнения операций можете обеспечить их выполнение во внутреннем генераторе, а во внешнем использовать его результат:

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

Ввод списка (массива) в языке Питон

• Простой вариант ввода списка и его вывода:

L=
L =  int(input()) for i in range(5)  # при вводе 1 2 3 4 5
print (L) # вывод: 1 2 3 4 5

Функция int здесь используется для того, чтобы строка, введенная пользователем, преобразовывалась в целые числа.

Как уже рассмотрено выше, список можно выводить целым и поэлементно:

# вывод целого списка (массива)
print (L)
 
# поэлементный вывод списка (массива)
for i in range(5): 
  print ( Li, end = " " )

Задание Python 4_7:
Необходимо задать список (массив) из шести элементов; заполнить его вводимыми значениями и вывести элементы на экран. Использовать два цикла: первый — для ввода элементов, второй — для вывода.

Замечание: Для вывода через «,» используйте следующий синтаксис:

print ( Li, end = ", " )

Пример результата:

введите элементы массива: 
3.0
0.8
0.56
4.3
23.8
0.7
Массив =  3, 0.8, 0.56, 4.3, 23.8, 0.7

Задание Python 4_8:
Заполните список случайными числами в диапазоне 20..100 и подсчитайте отдельно число чётных и нечётных элементов. Использовать цикл.

Замечание: .

Задание Python 4_9: Найдите минимальный элемент списка. Выведите элемент и его индекс. Список из 10 элементов инициализируйте случайными числами. Для перебора элементов списка использовать цикл.

Пример результата:

9 5 4 22 23 7 3 16 16 8 
Минимальный элемент списка L7=3

Последовательности

Ещё одно понятие из математики. Там, последовательность – есть нумерованный набор элементов, в котором возможны их повторения, а порядок имеет значение. Определение Питона схоже с математическим: здесь последовательностью зовётся упорядоченная коллекция объектов.

str (строка)

Строки, пожалуй, единственный объект, который может сравниться по степени своей используемости с числовым типом данных. Тавтологическое, но полное определение, справедливое для Python звучит так:

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

Строки, строки everywhere!

list (список)

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

Само название списков говорит об их предназначении быть объектами для хранения наборов данных. Список покупок, подарков, результатов матчей, ip клиентов или объектов типа Student. Списки в Python – это эдакие массивы из прочих языков «на максималках».

tuple (кортеж)

Кортежи в языке Python можно рассматривать, как неизменяемые списки со всеми вытекающими:

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

Функция map():

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

map(function, iterables)

Здесь функция определяет выражение, которое в свою очередь применяется к итерируемым элементам. Функция map может принимать функции, которые определил сам пользователь, а также лямбда-функции в качестве параметра.

Помимо того, мы писали уже про задачу, как можно сконвертировать список с применением функции map().

Базовое использование

Как создать список

Пустой список создается при помощи пары квадратных скобок:

empty_list = []
print(type(empty_list)) # <class 'list'>
print(len(empty_list)) # 0

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

homogeneous_list = 
print(homogeneous_list) # 
print(len(homogeneous_list)) # 6

heterogeneous_list = 
print(heterogeneous_list) # 
print(len(heterogeneous_list)) # 2

Для создания списков также может
использоваться конструктор list:

empty_list = list()  # Создаем пустой список
print(empty_list)  # []
new_list = list("Hello, Pythonist!")  # Новый список создается путем перебора заданного итерируемого объекта.
print(new_list)  # 

Также при создании списков используется List Comprehension, к которому мы еще вернемся.

Обращение к элементам списка

Вывод всего списка:

my_list = 
print(my_list)  # 

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

print(my_list)  # 1
print(my_list)  # 2
print(my_list)  # 9

В Python для обращения к элементам можно
использовать и отрицательные индексы.
При этом последний элемент в списке
будет иметь индекс -1, предпоследний —
-2 и так далее.

print(my_list)  # 25
print(my_list)  # 16
print(my_list)  # 9

Распаковка списков (для python-3). Если
поставить перед именем списка звездочку,
все элементы этого списка будут переданы
функции в качестве отдельных аргументов.

my_list = 
print(my_list)  # 
print(*my_list)  # 1 2 9 16 25

words = 
print(words)  # 
print(*words)  # I love Python I love

Списки мутабельны

Списки — это изменяемые контейнеры.
То есть, вы можете изменять содержимое
списка, добавляя и удаляя элементы.

Элементы списка можно перегруппировать,
используя для индексирования другой
список.

Создадим новый список из элементов списка , а индексы нужных элементов возьмем из списка :

my_list = 
my_index = 
my_new_list =  for i in my_index]
print(my_new_list)  #