Эмуляция поведения передачи по значению в Python

Нет никакого питонического способа сделать это.

Python предоставляет очень мало средств для принудительного применения таких вещей, как личные данные или данные только для чтения. Философия питона состоит в том, что «мы все взрослые по согласию»: в данном случае это означает, что «функция не должна изменять данные» является частью спецификации, но не применяется в коде.

Если вы хотите сделать копию данных, лучшее, что вы можете найти, - это ваше решение. Но copy.deepcopy, помимо того, что он неэффективен, также имеет предостережения , например:

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

[...]

Этот модуль не копирует такие типы, как модуль, метод, трассировка стека, фрейм стека, файл, сокет, окно, массив или любые подобные типы.

Поэтому я бы рекомендовал это только в том случае, если вы знаете, что имеете дело со встроенными типами Python или своими собственными объектами (где вы можете настроить поведение копирования, определив специальные методы __copy__ / __deepcopy__, нет необходимости определять свой собственный clone() метод. ).

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

>>> def passbyval(func):
def new(*args):
    cargs = [deepcopy(arg) for arg in args]
    return func(*cargs)
return new

>>> @passbyval
def myfunc(a):
    print a

>>> myfunc(20)
20

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

Обратите внимание, что следующие утверждения равны:

@somedecorator
def func1(): pass
# ... same as ...
def func2(): pass
func2 = somedecorator(func2)

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

Есть только несколько встроенных типов, которые работают как ссылки, например, list.

Итак, для меня питонический способ передачи значения для списка в этом примере будет:

list1 = [0,1,2,3,4]
list2 = list1[:]

list1[:] создает новый экземпляр списка1, и вы можете назначить его новой переменной.

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

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

В любом случае ... надеюсь, это поможет.

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

Я не могу найти другой вариант pythonic. Но лично я предпочел бы более OO способ.

class TheData(object):
  def clone(self):  """return the cloned"""

def f(data):
  #do stuff

def caller():
  d = TheData()
  f(d.clone())

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

import pickle

def f(data):
    data = pickle.loads(pickle.dumps((data)))
    #do stuff

В дополнение к ответу user695800 передайте по значению списки, возможные с помощью оператора [:]

def listCopy(l):
    l[1] = 5
    for i in l:
        print i

позвонил с

In [12]: list1 = [1,2,3,4]

In [13]: listCopy(list1[:])
1
5
3
4

list1
Out[14]: [1, 2, 3, 4]

Многие люди используют стандартную библиотеку copy. Я предпочитаю определять __copy__ или __deepcopy__ в своих классах. Методы в copy могут вызывать некоторые проблемы.

1. Неглубокая копия сохранит ссылки на объекты в оригинале вместо создания новых.
2. Глубокая копия будет выполняться рекурсивно, иногда может вызывать мертвую петлю. Если не уделять должного внимания, память может взорваться.

Чтобы избежать такого неконтролируемого поведения, определите свои собственные методы поверхностного / глубокого копирования путем перезаписи __copy__ и __deepcopy__. И ответ Алекса является хорошим примером.