Comments 44
Разве механизм CoW имеет отношение к языку??
То что вы описываете это просто работа ссылочного типа данных.
То что вы описываете это просто работа ссылочного типа данных.
Честно говоря, не знаю, введено ли подобное поведение в спецификацию языка или является особенностью реализации CPython. Но многие языки явно требуют наличие подобного механизма. Например.
Вот здесь небольшой список, где ещё это поведение является стандартом.
Если мне не изменяет память, в Delphi, Java и C# так же.
Вот здесь небольшой список, где ещё это поведение является стандартом.
Если мне не изменяет память, в Delphi, Java и C# так же.
Если мне не изменяет память, в Delphi, Java и C# так же.
Изменила, в Java и C# коллекции, поддерживающие CoW, вынесены в отдельные пакеты.
Замечание не про это. CoW и ссылки на объекты — это вещи из разных областей.
CoW означает, что при запросе на копирование (например, при присваивании в некоторых языках) объекта фактическое копирование данных происходит при попытке его изменить. Это способ оптимизировать работу с памятью отложив тяжёлую операцию на потом. Из того, что язык не поддерживает CoW вовсе не следует, что он не копирует объекты. Он вполне может копировать данные сразу при запросе на копирование.
Просто немного сбивает с толку абзац, в котором вы говорите, что Python не поддерживает CoW и иллюстрируете это тем, что он копирует ссылку, а не сам объект.
Скорее всего автор имел ввиду, что в python не использует CoW при управлении памятью, и ни чего больше. :)
ну, здесь уже точно понятно стало, что автор плавает в основах, например в понимании что такое ссылка, передача по ссылке итд
del
Прошу прощения, можно поподробнее объяснить то, в чём, как вы думаете, я плаваю?
Возможно, дело в термине «передача по ссылке» (в С++) — в этом случае вызываемая подпрограмма может изменить содержимое переменной, определённой в вызывающей программе.
Python передаёт параметры всегда по значению, но все переменные хранят указатели на значения. Т.е. вызываемая подпрограмма получает копию указателя, следовательно, она может изменить (если это указатель на изменяемый объект) значение указателя. НО не может изменить содержимое переданной переменной (чтобы она указывала на другой объект).
Python передаёт параметры всегда по значению, но все переменные хранят указатели на значения. Т.е. вызываемая подпрограмма получает копию указателя, следовательно, она может изменить (если это указатель на изменяемый объект) значение указателя. НО не может изменить содержимое переданной переменной (чтобы она указывала на другой объект).
Берем:
— все значения в python являются объектами, не зависимо от способа реализации на Си или python.
— все переменные являются ссылками на значение.
— тривиальные типы, числа и строки, при присваивании копируются. это касается и передачи в качестве параметра в функцию.
— при присваивании значений более сложных по конструкции происходит присваивание целевой переменной ссылки на исходное значение.
— для того, чтобы создать копию значения существуют функции copy/deepcopy, первая из которых выполняет поверхностное, а вторая глубокое копирование значения. кроме этого, можно перекрыть __copy__/__deepcopy__ функции, чтобы исключить копирование полей, специфичных для конкретного инстанса, например соединения с БД, или по сети.
— как альтернатива copy/deepcopy можно посмотреть на теневое копирование:
— а для особо экзотичных случаев есть модуль pickle, который позволяет сериализовать и десериализовать значения, со всем, что из этого следует.
def abc(x):
x.append(len(x))
a=[]
abc(a)
print(a) # [0]
abc(a)
print(a) # [0, 1]
abc(a)
print(a) # [0, 1, 2]
Python передаёт параметры всегда по значению, но все переменные хранят указатели на значения.Не согласен:
— все значения в python являются объектами, не зависимо от способа реализации на Си или python.
— все переменные являются ссылками на значение.
— тривиальные типы, числа и строки, при присваивании копируются. это касается и передачи в качестве параметра в функцию.
— при присваивании значений более сложных по конструкции происходит присваивание целевой переменной ссылки на исходное значение.
— для того, чтобы создать копию значения существуют функции copy/deepcopy, первая из которых выполняет поверхностное, а вторая глубокое копирование значения. кроме этого, можно перекрыть __copy__/__deepcopy__ функции, чтобы исключить копирование полей, специфичных для конкретного инстанса, например соединения с БД, или по сети.
— как альтернатива copy/deepcopy можно посмотреть на теневое копирование:
a=[1,2,3,4]
b=a[:] # можно явно b=list(a)
a+=[5,6,7,8]— а для особо экзотичных случаев есть модуль pickle, который позволяет сериализовать и десериализовать значения, со всем, что из этого следует.
Мне несколько непонятно, к чему ваш пример? Учитывая, что все переменные в
Переменная
«Передача параметра по ссылке» позволила бы внутри функции
python являются указателями на значения, что вы хотели показать с помощью примера? Я не вижу противоречий с тем, что я сказал.Переменная
a указывает куда-то в память на объект list, при вызове функции abc в локальную переменную x копируется переменная a (передача по значению), теперь x указывает на тот же объект list. Соответственно, все операции с x внутри abc меняют объект, на который также указывает и a.«Передача параметра по ссылке» позволила бы внутри функции
abc изменить переменную a, например так, чтобы она указывала на другой list или вообще dict. Этого в python, разумеется, нет, о чём я и сказал в предыдущем комментарии.Мне несколько непонятно, к чему ваш пример? Учитывая, что все переменные в python являются указателями на значения, что вы хотели показать с помощью примера? Я не вижу противоречий с тем, что я сказал.
При передаче в качестве параметра тривиального значения, например числа, копируется само значение, а при передаче, например, списка, передается ссылка на него. Организация связи имя_переменной->значение, в данном контексте, факт менее значимый.
При передаче в качестве параметра тривиального значения, например числа, копируется само значение, а при передаче, например, списка, передается ссылка на него.
Откуда сведения? В python даже числа — объекты… указатель на которые хранится в переменной и копируется при передаче в функцию. Неважно, переменная указывает на объект
5 или на объект [1, 2, 3], в функцию «прилетит» копия указателя на этот объект. Поиграйтесь с функцией id() — в CPython она возвращает адрес объекта в памяти.Организация связи имя_переменной->значение, в данном контексте, факт менее значимый.
Это как? Об этом же и рассуждаем, не?
Вся «засада» в терминологии: передача параметра в функцию «по ссылке» или «по значению» не имеет никакого отношения к самому значению — указатель там на что-то в памяти или банальный
uint8, неважно. Важно только то, что мы складываем на стек — значение, которое храниться в переменной или адрес этой самой переменной.Отчасти убедили, я упустил из виду, что питон хитро организует хранение переменных, и если вы раз написали a=1, а потом путем вычислений получили other_var=1, то id(a) и id(other_var) будут равны.
Это как? Об этом же и рассуждаем, не?на сколько я знаю, при передаче в функцию, к примеру, списочной переменной выделения памяти и копирования ее значения не происходит, что как раз обычно и происходит при передаче параметров по значению. Разве нет?
1 в python — это не байт со значением 0x01 и даже не 4 байта 00 00 00 01 (или 01 00 00 00), а объект класса int, хранящий значение 1 (сколько байт в памяти он будет занимать, если я правильно помню, зависит от платформы). В целях оптимизации интерпретатор заранее создает объекты-числа в диапазоне [-5, 256]. Поэтому, если a = 257, а потом путем вычислений получили other_var = 257, то id(a) != id(other_var). Это уже разные объекты, пусть и имеющие одно значение.Выделение памяти и копирование указателя как раз-таки и происходит при передаче параметров в функцию. Т.е. в функции вы всегда имеете дело с копиями ссылок на объекты. Просто для мутабельных объектов (changeable in-place) нет разницы как вы с ним манипулируете: через оригинальную ссылку (переменную вызывающей функции) или её копию (аргумент в вызываемой функции).
Препарирование вот такого кролика:
def abc0():
print(id([1, 300]))
def abc(x):
print(id(x))
a=300
print(id(a))
abc(a)
print(id(300))
print('---')
a=[1, 300]
print(id(a))
abc(a)
print(id([1, 300]))
abc([1, 300])
abc0()
140492550767728
140492550767728
140492550767728
---
140492518644424
140492518644424
140492518700616
140492518700616
140492518700616
По моему, с вашей версией поведения не совсем совпадает?a=300python создал объект класса int со значением 300 для литерала 300, в переменную a положил адрес этого объекта.
def abc(x):
print(id(x))
в локальную переменную x было скопировано значение переменной a, которая содержит адрес объекта 300, следовательно, x теперь тоже содержит адрес объекта 300
print(id(300))
поскольку значение переменной a ранее было задано литералом, который также используется и в данной инструкции, логично что инструкция выведет тот же адрес — зачем нам два литерала с одинаковым значением?
Если вы измените a=300 на a=299+1, то это не поможет, поскольку python достаточно умный, чтобы сразу создать литерал объекта-числа 300. А вот если сначала b=250, а потом a=b+50, то в коде программы уже литерал 300 не встречается и print(id(300)) придется создать новый объект числа 300.
Что касается списков, то тут я в затруднении — списковые литералы должны создаваться отдельными объектами, даже если они содержат одинаковые элементы. Возможно, интерпретатор достаточно умён, чтобы определить, что через переменную, хранящую адрес списка, сам список не изменяется… Т.е. тут у меня знаний не хватает, есть только догадки.
Вчера тупил интернет, не получилось вставить этот комментарий в тред, а сегодня все его игнорируют, может здесь он позаметнее будет. :)
Текст статьи тоже изменил.
Текст статьи тоже изменил.
Возможно, я не совсем понятно объяснил, что ж, попытаюсь быть понятнее.
В таких языках как C++ есть переменные, хранящиеся на стеке и в динамической памяти. При вызове ф-ции мы помещаем все аргументы на стек, после чего передаём управление ф-ции. Ф-ция знает размеры и смещения переменных на стеке, соответственно может их правильно интерпретировать.
При этом у нас есть два варианта: скопировать на стек память переменной или положить ссылку на объект в динамической памяти (или на более высоких уровнях стека).
Очевидно, что при изменении значений на стеке ф-ции, значения в динамической памяти не поменяются, а при изменении области памяти по ссылке, мы модифицируем общую память, соответственно все ссылки на эту же область памяти «увидят» новое значение.
В python отказались от подобного механизма, заменой служит механизм связывания(assignment) имени переменной с объектом, например при создании переменной:
Интерпретатор создаёт объект «john» и «имя» var, а потом связывает объект с данным именем.
При вызове ф-ции, новых объектов не создаётся, вместо этого в области видимости ф-ции создаётся имя, которое связывается с существующим объектом.
Но в python есть изменяемые и неизменяемые типы. К первым, например, относятся числа: при арифметических операциях существующие объекты не меняются, а создаётся новый объект с соответствующим значением, с которым потом связывается существующее имя. Если же со старым объектом после этого не связано ни одного имени, оно будет удалено с помощью механизма подсчёта ссылок.
Если же имя связано с переменной изменяемого типа, то при операциях с ней изменяется память объекта, соответственно все имена, связанные с данной областью памяти «увидят» изменения.
Можно почитать про это в документации, более подробно изложенно здесь.
В таких языках как C++ есть переменные, хранящиеся на стеке и в динамической памяти. При вызове ф-ции мы помещаем все аргументы на стек, после чего передаём управление ф-ции. Ф-ция знает размеры и смещения переменных на стеке, соответственно может их правильно интерпретировать.
При этом у нас есть два варианта: скопировать на стек память переменной или положить ссылку на объект в динамической памяти (или на более высоких уровнях стека).
Очевидно, что при изменении значений на стеке ф-ции, значения в динамической памяти не поменяются, а при изменении области памяти по ссылке, мы модифицируем общую память, соответственно все ссылки на эту же область памяти «увидят» новое значение.
В python отказались от подобного механизма, заменой служит механизм связывания(assignment) имени переменной с объектом, например при создании переменной:
var = "john"
Интерпретатор создаёт объект «john» и «имя» var, а потом связывает объект с данным именем.
При вызове ф-ции, новых объектов не создаётся, вместо этого в области видимости ф-ции создаётся имя, которое связывается с существующим объектом.
Но в python есть изменяемые и неизменяемые типы. К первым, например, относятся числа: при арифметических операциях существующие объекты не меняются, а создаётся новый объект с соответствующим значением, с которым потом связывается существующее имя. Если же со старым объектом после этого не связано ни одного имени, оно будет удалено с помощью механизма подсчёта ссылок.
Если же имя связано с переменной изменяемого типа, то при операциях с ней изменяется память объекта, соответственно все имена, связанные с данной областью памяти «увидят» изменения.
Можно почитать про это в документации, более подробно изложенно здесь.
При этом у нас есть два варианта: скопировать на стек память переменной или положить ссылку на объект в динамической памяти (или на более высоких уровнях стека).
ещё можно положить в стек ссылку на переменную, которую мы передаём в функцию
Очевидно, что при изменении значений на стеке ф-ции, значения в динамической памяти не поменяются
не понял, о чем речь — на стеке значение переменной? тогда о каком значении в динамической памяти идёт речь? или речь о том, что передаём указатель и если его поменять, то значение в динамической памяти не поменяется? так это, мягко говоря, очевидно
В python отказались от подобного механизма
уточните, пожалуйста, от какого именно механизма отказались, а то непонятно — сначала речь шла о передаче параметров и стеке функции, потом от какого-то механизма отказались… И, кстати, что за «механизм связывания(assignment)»? Не могу «нагуглить»… Любопытно, просто, чем он отличается от ссылок/указателей.
ещё можно положить в стек ссылку на переменную, которую мы передаём в функцию.
Именно это я и имел ввиду, когда писал
положить ссылку на объект в динамической памяти (или на более высоких уровнях стека).
не понял, о чем речь — на стеке значение переменной?
Мы создали переменную, например int32, где-то (на стеке или в памяти), при вызове ф-ции мы можем положить на стек само значение int32, или ссылку на него в памяти (или верхнем уровне стека), соответственно от этого зависит, увидим мы или нет изменения переменной по выходу из функции.
уточните, пожалуйста, от какого именно механизма отказались
Весь комментарий про это, внизу есть ссылки, или вас интересует реализация?
Если вкратце там словарь (имя переменной: ссылка на объект).
ideone.com/LPrD5j
«положить в стек ссылку на переменную, которую мы передаём в функцию» != «положить ссылку на объект в динамической памяти»
Давайте внимательно почитаем, что пишут по вашей же ссылке.
«call-by-reference» — это передача параметра по ссылке, если бы оно было в python, то могло бы выглядеть как-то так:
«просекаете фишку»? вот такая хрень и называется «передача параметра по ссылке», чего в python нет. Так какой правильный ответ «на собеседованиях» на вопрос «как передаются в python параметры в функцию: по ссылке или по значению?»
[зануда mode on]
не, меня интересует ровно то, что я спросил: «от какого механизма отказались?»
И по ссылке тоже не нашел, что за механизм связывания (assignment) — там есть про то, что «присваивание создаёт ссылку на объект» и «аргументы передаются присваиванием»
[зануда mode off]
Давайте внимательно почитаем, что пишут по вашей же ссылке.
«call-by-reference» — это передача параметра по ссылке, если бы оно было в python, то могло бы выглядеть как-то так:
def cbr(&x):
x = {}
a = [0, 1, 2]
cbr(a)
print(a) # {}
«просекаете фишку»? вот такая хрень и называется «передача параметра по ссылке», чего в python нет. Так какой правильный ответ «на собеседованиях» на вопрос «как передаются в python параметры в функцию: по ссылке или по значению?»
[зануда mode on]
Весь комментарий про это, внизу есть ссылки, или вас интересует реализация?
не, меня интересует ровно то, что я спросил: «от какого механизма отказались?»
И по ссылке тоже не нашел, что за механизм связывания (assignment) — там есть про то, что «присваивание создаёт ссылку на объект» и «аргументы передаются присваиванием»
[зануда mode off]
UFO just landed and posted this here
это не «интересности и полезности», а «грабли и мины» — правильное использование всего этого разве что запутает читающего код, а вот наступить и заюзать неправильно можно.
С передачей параметров как раз всё понятно, в вот кто бы объяснил почему -22//10=-3, я читал ЧаВо, но не смог понять.
А сколько должно быть?)
В руби так же
ideone.com/eMm8Dh
Происходит это потому, что остаток от деления принято делать лежащим в интервале от 0 до делителя, то он отрицательным быть не может.
print(-22 // 10) # -> -3
print(-22 % 10) # -> 8
В руби так же
ideone.com/eMm8Dh
Происходит это потому, что остаток от деления принято делать лежащим в интервале от 0 до делителя, то он отрицательным быть не может.
Вообще-то в числе 22 десятка умещается только два раза (именно поэтому 22//10=2), откуда три можно взять?
В статье, ссылку на которую, я сбросил, сказано, что обычно в математике остаток считают положительным, число -22 представляется в виде:
-22 = -3 * 10 + 8
-22 = -3 * 10 + 8
А какую задачу вы решаете, что упираетесь в это?
Cлучайно наткнулся, точно не помню, возможно листая официальный faq.
А тут поясняют когда на это можно напороться.
Тут пишут
хотя похоже что питон использует математически верную реализацию
When either a or n is negative, the naive definition breaks down and programming languages differ in how these values are defined.
хотя похоже что питон использует математически верную реализацию
Лучше не использовать целочисленное деление и floor/ceil для отрицательных чисел.
А по мат. определению дробная часть {-2,7} = 0.3.
А возвращаясь к остатку от деления, как правильно сказано в приведённой вами ссылке, обычный способ проверки на нечётность — это y % 2 == 1
Будет обидно, если эта проверка сломается из-за того, что для некоторых чисел данный остаток будет равен -1. Так что лучше не вводить отрицательных остатков.
import math
e = 2.7
print(math.floor(e), math.floor(-e)) # - > 2 -3
print(math.ceil(e), math.ceil(-e)) # - > 3 -2
А по мат. определению дробная часть {-2,7} = 0.3.
А возвращаясь к остатку от деления, как правильно сказано в приведённой вами ссылке, обычный способ проверки на нечётность — это y % 2 == 1
Будет обидно, если эта проверка сломается из-за того, что для некоторых чисел данный остаток будет равен -1. Так что лучше не вводить отрицательных остатков.
Всё оказалось как-то мутнее.
По-моему, книга Бизли Python. Книга рецептов. будет как минимум полезней.
И наверное, тоже интересной.
И наверное, тоже интересной.
Прежде всего спасибо за наводку. (Скоро рекомендаций наберётся на отдельную статью).
Мы уже обсуждали этот вопрос.
Разумеется, язык лучше усваивать на хорошем курсе в универе, потом, пожалуй, идёт книга, а данные статейки в интернете созданы для тех, кто в своё время не успел по разным причинам прочесть эти книги или посетить курс.
У вас вот нет времени читать все статьи из цикла и комментарии к ним, у кого-то нет времени читать несколько книг. :) Так как перекинули на новый проект, который нужно сдавать вчера\вдруг что-то навернулось в работавшей несколько лет системе\через неделю сдавать курсач.
Ну и кроме того, книг много, прочитав одну, не факт, что начнёшь другую, так как и рабочая и личная жизнь диктует своё, а в книге могли что-то не рассматривать, она могла уже устареть.
Надеюсь, всё же в цикле было несколько фактов, которые вы не знали.
Мы уже обсуждали этот вопрос.
Разумеется, язык лучше усваивать на хорошем курсе в универе, потом, пожалуй, идёт книга, а данные статейки в интернете созданы для тех, кто в своё время не успел по разным причинам прочесть эти книги или посетить курс.
У вас вот нет времени читать все статьи из цикла и комментарии к ним, у кого-то нет времени читать несколько книг. :) Так как перекинули на новый проект, который нужно сдавать вчера\вдруг что-то навернулось в работавшей несколько лет системе\через неделю сдавать курсач.
Ну и кроме того, книг много, прочитав одну, не факт, что начнёшь другую, так как и рабочая и личная жизнь диктует своё, а в книге могли что-то не рассматривать, она могла уже устареть.
Надеюсь, всё же в цикле было несколько фактов, которые вы не знали.
Sign up to leave a comment.
Интересности и полезности python. Часть 3