#14. Срезы списков и сравнение списков | Python для начинающих

[@IoldxmanI]

Будет здорово, если получится в курсе увязать теорию с практическим применением) Вы очень доходчиво объясняете материал, спасибо!

[@ХалилМаденбай]

это будет в степике скоро

[@krab9241]

отличные задачи на stepik !!!💪

[@andreitatar7752]

Отличная подача материала!!!

[@andreychernykh256]

интересно следить как падает количество просмотров с каждым последующем видео. Но автору большой респект за этот труд!!!!!!! Вы великолепный преподаватель, это мы бараны)

[@selfedu_rus]

бараны - это те, кто бросает =)

[@donfedor007]

@@selfedu_rus Люди боятся покинуть зону комфорта. Учить программирование это труд. Причём плоды от этого труда, получится получить только в не очень близкой перспективе.

[@AZ993k]

Да, тоже обратил внимание. Тем более хочется дойти до конца. Реально просто и интересно

[@stilllifeenthusiast]

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

[@neuroofun4627]

@@selfedu_rus остаются те, кому это дейсвительно нужно, а тот пласт людей который со временем рассасывается, они толком не понимают куда они пришли, и что это вообще такое

[@olegkomlev]

9:38 Использована операция marks += [3] Эта операция изменяет список, вставляя в него еще один элемент 3. Ранее было показано аналогичное присваивание для чисел (например, x +=1 увеличивает целую переменную на 1). Но если для чисел x +=1 это просто сокращение для x=x+1, то для списков L += S и L = L+S не одно и то же. Здесь L и S - некоторые списки. Например, операторы L=[1,2] M=L L +=[3] #изменяет список L, а заодно и М print (L, M) дают результат [1, 2, 3] [1, 2, 3] Но фрагмент L=[1,2] M=L # создает новый список, который присваивается переменной L L = L + [3] print (L, M) выдаст результат [1, 2, 3] [1, 2]

[@coscosru]

вау! внезапно. Спасибо за подсказку!

[@3kanala]

Хмм, интересно. В первом случае адрес памяти не меняется, список до записывается на тоже место в памяти. Тоже самое делает L.append(3) одно и тоже с L += [3]. Во втором - М остаётся ссылаться на первую ячейку памяти, а при L = L + [3] справа выделяется память под новый список и эта ссылки присваивается L. Я предположу что L = L + [3] тоже самое L = list(L + [3]). Если есть мысли по этому поводу дополняйте)

[@МаксГришин]

Хорошие курсы - весьма доходчиво и простым языком автор доносит.Бесконечная благодарность за это.К этим курсам я бы рекомендовал книгу: "Python для начинающих" автора Джейсон Бриггс.

[@Alexey_3120]

Преподавателю поклон!)

[@ordinar007]

отличный курс! с удовольствием смотрю уроки, всё мне понятно

[@thebaingames5636]

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

[@elenalevasheva3830]

Спасибо за урок, посмотрела с удовольствием

[@supercryning6079]

Хорошо рассказываете. Решил повторить изученный материал, и что-то новое узнал.

[@Аурика-ы7я]

Спасибо большое

[@ОлегД-е5э]

О механизме формирования Среза произвольного списка. Все утверждения ниже будут справедливы для Срезов любых упорядоченных итерируемых объектов (строка, список, кортеж). Все началось с того, что при знакомстве со Срезами было непонятно, почему при формировании Среза строки А[ i: j] элемент исходной строки А с первым индексом Среза (”i”) в результат Среза включается, а элемент исходной строки А со вторым индексом Среза (”j”) - не включается. Так языки программирования не пишутся. В результате поиска ответа на поставленный вопрос выяснилось следующее.... Модель работы Среза. В основе действия оператора Среза строк лежит процедура “Исключения Пересечения” двух упорядоченных множеств (списков), или, в терминах школьной математики, - операция “Вычитания” одного списка из другого. Грубо, утверждение выше можно записать следующим образом: Срез А[ i: j: dir_step] = Изменяемый список(порожденный i) - Вычеркиваемый список (порожденный j). Правило формирование Изменяемого и Вычеркиваемого списков Среза следующие: п.1. Индекс ”i” в параметрах Среза отвечает за формирование Изменяемого списка, который включает в себя все элементы исходного списка А начиная с элемента с индексом ”i” и заканчивая включением крайнего (последнего) элемента исходного списка А. п.2. Индекс ”j” в параметрах Среза отвечает за формирование Вычеркиваемого списка, который включает в себя все элементы исходного списка А начиная с элемента с индексом ”j” и заканчивая включением крайнего (последнего) элемент исходного списка А. Замечание: Термин “...крайнего (последнего)...” выбран не случайно, но осознанно. За детальными разъяснениями см. раздел про параметр ”dir_step”. Процедура “Вычитания” реализуется последовательным вычеркиванием из Изменяемого списка всех элементов содержащихся в Вычеркиваемом списке (это очень экономичная, с вычислительной точки зрения, процедура). Пример формирования Среза A[2:4] из исходного списка: A= [0, 1, 2, 3, 4, 5, 6, 7] . Изменяемый список = [2, 3, 4, 5, 6, 7] Вычеркиваемый список= [4, 5, 6, 7] Последовательно, справа налево, вычеркиваем поочередно совпадающие элементы в обоих списках: сначала 7-ки, затем 6-ки, потом 5-ки, и, наконец, 4-ки. В результате, Срез A[2:4] вернет список [2, 3]. Теперь ясно, что раз элемент с индексом ”j” вычеркивается из Изменяемого списка, то Срез списка А элемент с индексом ”j” содержать и не будет. Общие Правила формирования Среза списка А, в терминах списков (но не индексов) Правило.1. Если поле Среза для индекса ”i” пустое, то в Изменяемый список заносится Исходный полный список А (ну надо же нам из чего-то вычеркивать), в противном случае - Изменяемый список формируется по алгоритму п.1. Правило.2. Если поле Среза для индекса ”j” пустое, то Вычеркиваемый список ПУСТОЙ - ничего вычеркивать не будем, в результате Срез равен Изменяемому списку. В противном случае Вычеркиваемый список формируется по алгоритму п.2. О назначении параметра Среза ”dir_step”. В параметре “dir_step” важен Знак и Величина параметра. а) Если значение параметре “dir_step” >= 0 (неотрицательно или параметр не указан), то перебор элементов, при формировании Изменяемого и Вычеркиваемого списков ведется Слева- Направо, последним элементом обеих списков будет крайний правый элемент исходного списка - А[-1]. Для примера: Срез А[2: 4: 1] Исходный список A = [0, 1, 2, 3, 4, 5, 6, 7] Изменяемый список = [2, 3, 4, 5, 6, 7] Вычеркиваемый список = [4, 5, 6, 7] В результате Срез А[2: 4: 1] вернет [2, 3]. б) Если значение параметре “dir_step” < 0 (строго отрицательный), то перебор элементов, при формировании Изменяемого и Вычеркиваемого списков ведется в ОБРПАТНОМ Порядке СПРАВА-НАЛЕВО (как у арабов). Поэтому, последним элементом обеих списков будет крайний левый элемент исходного списка - А[0]. Для примера: Срез А[5: 2: -1] Исходный список A = [0, 1, 2, 3, 4, 5, 6, 7] Изменяемый список = [0, 1, 2, 3, 4, 5] Вычеркиваемый список = [0, 1, 2] В результате Срез А[5: 2: -1] вернет [3, 4, 5]. Про величину параметра “dir_step” в интернете написано верно, повторятся не буду. В заключении. Выше описан лишь механизм формирования Среза. А хотелось бы еще сказать про идеологию Срезов. Срез возвращает данные, но оперируем в Срезе мы не ими. Если картина сложится, поделюсь своим взглядом.

[@andredru4278]

Спасибо. Узнал новое.

[@jamjam3337]

Спасибо!👏👍

[@ОлегД-е5э]

Урок 14 Срезы списков После опубликования настоящего комментария изменились представления о механизме создания копий в Phython. Это потребовало внести изменения в настоящий комментарий. 1. Утверждения из видео «... Срез создает новый список, который содержит соответствующие элементы...» (тайминг видео 1:28) и «...Это как раз говорит о том, что вот этот вот срез, вот эта вот коллекция, она совершенно независима от начального списка...» (тайминг видео 2:03) - не всегда будут справедливы. И первое и второе утверждение полностью справедливы для приведенного на видео примера с элементами неизменяемого типа данных в списке, и Не будут справедливы для случая, если хотя бы один из элементов списка будет представлен Изменяемым типом данных. 2. Срез не создает новый список с независимыми объектами. Срез создает список из ссылок!!!, которые ссылаются на соответствующие объекты исходного списка. К примеру, элемент списка Lst[1] и элементе среза A[0] будут содержать одинаковую ссылку на один и тот же объект исходного списка - «Уфа». А элемент списка Lst[2] и элементе среза A[1] будут содержать одинаковую ссылку на один и тот же объект исходного списка - «Тверь». Еще раз, соответствующий элемент исходного списка и соответствующий элемент среза всегда будут ссылаться на один и тот же (не различные) объект исходного списка. 3. В этом несложно убедиться. Для этого необходимо в исходном списке, к примеру, объект «Уфа» сделать ИЗМЕНЯЕМОГО типа, вот так - [«Уфа»]. Тогда исходный список будет выглядеть так Lst = [ «Москва», [«Уфа»], “Тверь», «Казань»]. Срез A=Lst[1:3] будет ссылаться на следующую коллекцию - [[«Уфа»], “Тверь»]. Теперь изменим значение элемента «Уфа» на значение «Омск», вот так A[0][0] = “Омск» .В результате, в исходном списке Lst, значение «Уфа» измениться на значение «Омск». Что и подтверждает прямую связь соответствующих элементов списка и среза для случая, когда элементы списка представлены произвольными объектами именно ИЗМЕНЯЕМОГО типа. 4. Идеология создания копий в Python несколько необычна, сильно отличается об "бытовых"-общепринятых представлений о копии объекта. Этому следовало-бы посвятить отдельный комментарий. 5. По моему мнению, о важности концепции Изменяемых данных в языке Python следовало бы рассказывать в самом начале изучения языка и уделить этой концепции достаточное время.

[@selfedu_rus]

Все верно, возможно, действительно, этим нюансам следует уделить больше внимание?! Подумаю, спасибо!

[@podgorniy.r]

@@selfedu_rus было бы здорово, так как иногда вообще не ожидаешь такого поведения когда работаешь с копиями списков =)

[@Rusia-16]

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

[@selfedu_rus]

pet-проекты, потом реальные проекты и так далее...

[@Rusia-16]

@@selfedu_rus Thanks !

[@ibrahimoglu]

👍

[@gayratsaidakhmedov5451]

спасибо

[@oopsimath]

9:55 Ошибка возникает из-за того, что в коллекции нечётное (точнее не кратное 3-м) количество элементов

[@DmitryTimofeev]

Большое спасибо! Когда вы рассказывали про то, что через срез без начального и конечного индекса ( [ : ] ) часто создают копии списка, подумал, а почему просто нельзя для дублирования списка присвоить ему другую переменную (lst = lst2). Оказалось, что в случае внесения каких-либо изменений в первоначальный список, дубликаты сделанные через срез и через присвоение переменной поведут себя по-разному. Дубликат сделанный через срез - останется без изменений (сохранит первоначальный вид спика), а дубликат сделанный через присвоение переменной - изменится соответственно внесённым изменениям в первоначальный список. А ещё давно интересует такой вопрос. Как я понял удаление элемента из списка, или печать(вывод) элемента списка может быть осуществлено только для одного конкретного элемента (индекса) или для среза. А возможно ли удалить или напечатать, например: 0, 2 и 4 индексы списка? Буду благодарен, если ответите, так как очень любопытно. PS: я изучаю уроки частями для лучшего их освоения, поэтому, если ответ на мой вопрос содержится в конце этого урока или в будущих уроках, то тогда прошу прощения за вопрос, и прошу вас не тратить ваше время на ответ в таком случае.

[@oopsimath]

В Пайтоне нет переменных и не бывает присвоения - есть именованные объекты и связывание их со значением имеющим ID (адрес). Можно всё

[@vlad-qx5fu]

👆🙌👏🤝🙏 Спасибо.

[@ШепотСмерти-ш8м]

top

[@macktraher_mvp3580]

Шаги, это жесть конечно вынос мозга. Нужно очень напрячься (лично для меня), чтобы понять "шаги". На практике при написании ботов (например для тг), сайтов, эти "шаги" практически не используются. Чтобы не выгорать и не ломать себе мозг на старте, советую не зацикливаться на чем-то не особо нужном вроде "шагов". Лично у меня цель научиться делать сайты, ботов для телеграмм для начала и если я буду тратить кучу времени, чтобы понять не особо нужную мне тему, я очень быстро выгорю. Подход должен быть с умом. То, что не понял, придет с опытом

[@МамкинаРадость-с4е]

А можно ли присвоить определенным элементам среза одно и то же значение, не прописывая их количество. Ну что-то типа marks [:8:2]=5? То есть чтобы все элементы от начала до восьмого с шагом 2 изменились на 5? Как это реализовать в Python?

[@selfedu_rus]

так вот на вскидку, вроде нет

[@МамкинаРадость-с4е]

@@selfedu_rus Благодарю за ответ. Просто складывается ощущение, что я делаю работу за Python🤣: сначала посчитай, сколько надо присвоить, затем присвой...

[@andrus3125]

Такое лучше в numpy проворачивать

[@ОлегД-е5э]

О механизмах Копирования объектов в языке Python. (решил оставить комментарий здесь, поскольку это видео подтолкнуло разобраться с копирование объектов). Перефразируя Роберту Иерузалимского, одного из авторов языка Lua, когда-то заявившего, что - «Таблицы - наше все», Гвидо ван Россему (ок. спасибо, поправил фамилию), сами знаете кто, следовало бы объявить - «Таблицы ссылок - наше все!». Процедура создание копий объектов данных является очень затратной вычислительной процедурой. Поэтому в языке Python процедура Копирования, реализована, в зависимости от типа данных оригинала, одним из следующих способов: 1) для объектов данных неизменяемого типа, кортежей, а также, для простых, без вложения, списков и множеств - через создание простой ссылки на исходный объект копирования (оригинал) с помощью оператора присваивания - « = » (равно) ; 2) для вложенных списков и множеств - по двух шаговой схеме, сначала оригинал перепаковываем методом “(*Object, )” в такой же вложенный (многоуровневый) кортеж; затем многоуровневый кортеж перепаковываем методом “[*Object, ]” обратно в в многоуровневый список; 3) для копирования словарей, вероятно, применяются именованные кортежи, но с ними я еще не разобрался, поэтому это не точно, только версия. И еще одно замечание - Оператор id() Бесполезен для определения того факта, что один объект является копией другого.

[@ОлегД-е5э]

Продолжение. Одним комментарием не разместилось. Для подтверждения вышеизложенного введем «наивное» определение копирования, и на модельных примерах разберем, к чему это приведет. Утверждение - Для того, чтобы объект В являлся точной копией исходного оригинала А необходимо и достаточно выполнения следующих двух условий: 1) при поэлементном сравнении каждый элемент объекта В должен быть полностью идентичен соответствующему элементу исходного оригинала А; 2) при произвольном изменении исходного оригинала А объект В остается полностью неизменным, . Выполнение первого условия обеспечивает полную идентичность исходного оригинала А и копии В. Выполнение второго условия обеспечивает независимое, от исходного оригинала А, существование копии В после ее создания. Несложно видеть, что приведенное выше Утверждение не противоречиво. На практике, пункт 1) может быть реализован одним из следующих способов: 1) через обычный оператор присваивания - « = » (равно) ; 2) через оператор среза - Object[x:y] ; 3) через оператор “распаковки-перепаковки» - [*A] или (*А, ). Рассмотрим процедуру копирования на примере списка А. Пусть оригинал объекта задан модельным простым (не вложенным) списком вида: А = [“a”, “b”, 3]. Рассмотрим простой код: 1. А = [“a”, “b”, 3] 2. B = A 3. print(B) 4. A[0] = “g” 5. print(A) 6. print(B) Необходимо ответить на вопрос - является ли объект В копией объекта А? Разберем код примера по строкам. Строка1. Интерпретатором будет создан исходный объект (оригинал) класса «список». Список на этот объект будет помещена в переменную А. Очевидно, что: а) поле списка А[0] содержит ссылку на неизменяемый тип данных “string” со значением “a”; б) поле списка А[1] содержит ссылку на неизменяемый тип данных “string” со значением “b”; в) поле списка А[2] содержит ссылку на неизменяемый тип данных “number” со значением 3 (три). В результате, создан список А, в полях которого располагаются ссылки на другие объекты (ничего нового, все как на видео). Строка2. Итератором будет создан Второй объект типа «список» с НОВЫМ адресом размещения, который и будет передан в переменную В. При этом: а) поле списка В[0] будет содержат ту же самую ссылку, что и А[0], на неизменяемый тип данных “string” со значением “a”; б) поле списка В[1] будет содержат ту же самую ссылку, что и А[1], на неизменяемый тип данных “string” со значением “b”; в) поле списка В[2] будет содержать ту же самую ссылку, что и А[2], на неизменяемый тип данных “number” со значением 3 (три). В результате, будет создан список В, в полях которого располагаются ссылки, идентичные соответствующим ссылкам списка А, на одни и те же объекты данных, на которые ссылается и список А. («Таблицы ссылок - наше все!» Гвидо ван Россен.) Строка3. Очевидно, что оператор print(B) вернет список [“а”, “b”, 3] . Таким образом, Первое условие Утверждения Выполнено!!! Строка4. Поскольку список - это объект изменяемого типа данных, то в поле А[0] списка А, будет записана новая ссылка на объект “g”. Теперь переменная А будет ссылаться на список следующего вида - [“g”, “b”, 3]. Строка5. Тогда очевидно, что оператор print(А) вернет список [“g”, “b”, 3] . Строка6. Поскольку ссылки в списке В не менялись, то оператор print(B) по прежнему вернет список [“а”, “b”, 3]. Из результатов Строк 5 и 6 следует, что выполнено Второе условие Утверждения!!! А это означает, что список, на который ссылается переменная В и есть КОПИЯ исходного первоначального списка [“а”, “b”, 3]. И Копия эта была получена из исходного списка только с помощью одного оператора присваивания “ = ” (строка2). Важное замечание. Несложно увидеть, что если вместо списка использовать другой произвольный вид неизменяемого типа данных, к примеру, строку вида А = “str1” или число, то оператор присваивания “ = ” в выражении В = А снова запишет в В ссылку на Копию исходного объекта “str1”. Это пример интересен еще и тем, в этом случае id() переменных А и В будут одинаковы, id(А) = id(В). Но, в первом примере, со списком, id() переменных А и В будет отличаться. Отсюда, со всей очевидностью, следует вывод, что оператор id() Бесполезен при ответе на вопрос - Является ли один объект копией другого? Оператор id() возвращает адрес объекта, а внутри объекта - только ССЫЛКИ, а на какие данные ссылаются эти ссылки оператор id(), разумеется, «не знает”. В заключении. Для вложенных списков произвольной грубины и сложности надо писать программу по перепаковке данных, простое однократное применение оператора (*Object,) не прокатит. За основу следует взять алгоритм, описанный у Сергея в курсе «Структуры данных» (реализация алгоритма в видео #18 “Реализация бинарного дерева на Python”, метод называется «Обход вершин дерева в глубину») и занимает не более 30-40 строк кода. Создание копий Словарей - пока вопрос открытый, «руки еще не дошли». НО, полагаю, что именно для этого предназначены именованные кортежи.

[@lindx2533]

Ну по сути все тоже самое что и со строками, кольто вместо букв, элементы списка, которые можно рассматривать будто бы символы

[@shaykhinurov]

Я из Уфы, интересно видеть название этого города )

[@testingvlad211]

🦾 Merci☝🖖👋👏🙌

[@elshadbaku2002]

10:02 точно не понял

[@timohahahehehe]

11:26

[@timohahahehehe]

8:22

[@boyboy-hk2ki]

lst1 = [4,6,8,5] lst2 = slice(1,3) print(lst1[nnn]) >>> [6, 8] ; ведь это тоже срез?

[@gore_ot_uma166]

так не работает, так как в срез lst1 попадает не срез, а список, т.е. получается lis1[[1, 3]]. во-первых это список в списке, вторая ошибка - срез пишется через двоеточие

[@EugeneShperl]

Объясните тупому почему инверсия списка работает marks[::-1] , а не marks[-1::] ,когда marks[0::] работает как надо? Спасибо

[@НастяТефтель]

Предполагаю что когда вы указываете начальное значение [1::] или любое другое число, перечисление элементов списка всегда происходит слева направо, поэтому когда вы указываете [-1::](что является последним элементом), у вас выводится только он, тк после него(справа) ничего нет. Когда вы делаете шаг отрицательным(то есть шагаешь вперёд это слева направо, а тут как бы в отрицательную сторону) шаги делаются справа налево поэтому происходит нужное действие🦧 надеюсь кому-то поможет понять

[@oopsimath]

marks[-1::] => -1 меньше 0, что является ошибкой

[@stragess4054]

Я из твери😂