Возведение в степень

Округление десятичного числа

При работе с десятичными числами важно иметь возможность быстро округлить его до N знаков после запятой. Строенная функция round() выполняет эту задачу

При этом ей необходимо два числа: A – число, которое нужно округлить, B – количество знаков после запятой.

Например:

Попробуйте написать простую программу, которая будет подсчитывать чаевые. К примеру, три человека хотят разделить счет в ресторане в $87.93 и оставить 20%  чаевых.

В результате получилось число с большим количеством десятичных знаков. Функция round() округлила его до двух знаков после запятой.

Чтобы округлить десятичное число до целого числа, задайте 0 в качестве второго параметра (в данном случае тип данных не преобразуется, после запятой будет 0):

Функция round() может работать и с целыми числами. Если в качестве первого параметра задано целое число, в результате функция также вернёт целое число.

Значения -inf, inf и nan

Тем не менее вместо ошибок OverflowError, когда число выходит за указанные пределы, иногда появляются значения и :

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

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

И мы получили — значение, которое означает неопределяемое число (или «не число»). Но оно ведет себя как число, и в каком бы выражении оно не появилось, результат всегда будет (кроме т.к. деление на \(0\) всегда приводит к появлению ошибки):

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

Степень

Целочисленная

В целочисленную степень можно возводить положительные и отрицательные и числа:

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

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

Результат не определён, когда 0 возводят в отрицательную степень:

Ошибка деления на ноль возникает из-за следующего свойства степени:

Рациональная

Возведение числа в рациональную степень напрямую связано с извлечением корня из этого числа отношением:

Если рациональный показатель отрицательный, а основание равно нулю, то Питон все ещё будет выдавать ошибку:

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

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

Вещественная

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

Python умеет возводить в вещественную степень даже вещественные числа (пусть и псевдо)

Сделать такое инструментами математики ой как непросто:

Использование модуля pickle на своих объектах

протокол

Сериализация собственных объектов.

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

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

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

• Если во время десериализации определён , то данные объекта будут переданы сюда, вместо того чтобы просто записать всё в . Это парный метод для : когда оба определены, вы можете представлять состояние вашего объекта так, как вы только захотите.

• Если вы определили свой тип (с помощью Python’s C API), вы должны сообщить Питону как его сериализовать, если вы хотите, чтобы он его сериализовал. вызывается когда сериализуется объект, в котором этот метод был определён. Он должен вернуть или строку, содержащую имя глобальной переменной, содержимое которой сериализуется как обычно, или кортеж. Кортеж может содержать от 2 до 5 элементов: вызываемый объект, который будет вызван, чтобы создать десериализованный объект, кортеж аргументов для этого вызываемого объекта, данные, которые будут переданы в (опционально), итератор списка элементов для сериализации (опционально) и итератор словаря элементов для сериализации (опционально).

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

Как отфильтровать элементы с помощью takewhile() и drop while()

Мы можем использовать Python для фильтрации элементов последовательности, если условие . Если условие становится , фильтрация прекращается.

iterator = itertools.takewhile(condition, *sequence)

Вот простой пример, который фильтрует числа, если число положительное.

import itertools

sequence = itertools.takewhile(lambda x: x > 0, )

for item in sequence:
    print(item)

Выход

1
2
3

Здесь последовательность остановилась после 3, поскольку следующий элемент равен -1.

Точно так же фильтрует элементы, пока условие имеет значение и возвращает все элементы после первого значения, отличного от false.

import itertools

data = itertools.dropwhile(lambda x: x < 5, )
for item in data:
    print(item)

Выход

12
7
1
-5

Перебор последовательности с помощью itertools.cycle()

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

Рассмотрим два состояния лампочки: «включено» и «выключено».

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

import itertools

# Initially, bulb is switched off, so off is the first element in the list
bulb_states = itertools.cycle()

for _ in range(5):
    # Use next(iterator) to get the current state
    curr_state = next(bulb_states)
    print(f"Bulb state currently {curr_state}")

Выход

Bulb state currently off
Bulb state currently on
Bulb state currently off
Bulb state currently on
Bulb state currently off

Состояние лампочки постоянно меняется между двумя значениями «включено» и «выключено».

Комплексные числа (complex)

В Python встроены также и комплексные числа:

Также для работы с комплексными числами используется также модуль cmath.

В программировании мы всегда взаимодействуем с данными, которые не являются какой-то абстрактной субстанцией. Все данные разделяются по определенному типу. На предыдущих уроках мы узнали, про строки, списки, словари и о логическом типе данных. Сегодня, поговорим о самом базовом типе данных в Python — числах.

Почему нельзя свалить все данные в одну общую кучу и не заморачиваться с каждым типом по отдельности? Допустим, мы присвоили переменной a цифру 5: a = 5. А теперь представьте, что никакого разделения по типу данных нет. Так что находится в переменной: число или строка? Если 10 — это число, то с ним можно произвести математические действия. А если это строка, то мы имеем дело с текстом и тогда Python задействует совсем другие методы.

# объединение строк (конкатенация) d = ’10’ f = ‘негритят’ d + ‘ ‘ + f ’10 негритят’

Ключевой момент: У каждого типа данных свои методы.

Цифра 100 написанная без кавычек, относится к числовому типу данных. А цифра ‘100’ в кавычках — к строковому типу. С помощью синтаксиса, мы сообщаем Python, какой у нас тип данных. Числа в Python делятся на два вида: целое число и вещественное.

Сложение и вычитание

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

Например:

Также вы можете объявить переменные и указать их в функции print:

Целые числа бывают положительными и отрицательными. Попробуйте сложить следующие числа:

Числа с плавающей точкой складываются аналогичным образом:

В результате сложения чисел с плавающей точкой также получается число с плавающей точкой, потому Python выводит 8.0, а не 8.

Синтаксис вычитания отличается от сложения только оператором. Попробуйте отнять 32 из 75.67:

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

Для чего нужен модуль Decimal?

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

Перед тем, как мы ответим на данный вопрос, мы хотим, чтобы вы сами посчитали в Python, какой результат будет в данном примере: 0.1+0.2? Вы будете удивлены, когда узнаете, что правильный ответ – это не 0,3, а 0,30000000000000004.

Чтобы понять, почему в расчетах возникла ошибка, попробуйте представить 1/3 в десятичной форме. Тогда вы заметите, что число на самом деле не заканчивается в базе 10. Так как все числа должны быть каким-то образом представлены, при их сохранении в консоли делается несколько приближений, что и приводит к ошибкам.

Cпециально для читателей-гуманитариев, у нас есть объяснение принципов работы модулей Питона: «Она на долю секунды отвела взгляд» и «Она отвела взгляд на короткое время» — чувствуете разницу?

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

Системы счисления

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

Десятичные целые числа создаются, как обычно, с помощью десятичных цифр:

причем, в десятичной системе счисления ни одно число, кроме нуля не может начинаться с цифры \(0\), что в общем-то и ежу понятно, но это значит что отбрасывания незначащих нулей не происходит, а их наличие приводит к ошибке:

Двоичные числа состоят из префикса (или ) и двоичных цифр: \(0\) и \(1\):

Восьмеричные числа начинаются с префикса () и могут содержать только восьмиричные цифры: \(0\), \(1\), \(2\), \(3\), \(4\), \(5\), \(6\) и \(7\):

Шестнадцатеричные числа начинаются с префикса () и могут содержать как все десятичные цифры, так и символы латинского алфавита: (или ), которые в данном случае выступают в роли цифр:

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

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

Способы извлечения корня

В языке программирования Python 3 существует три способа извлечения корней:

• Использование функции sqrt из стандартной математической библиотеки math.
• Операция возведения в степень **
• Применение функции pow(x, n)

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

from math import sqrt
x = sqrt(4)
print(x)

2.0

Если же нам нужно вычислить в Python корень квадратный из суммы квадратов, то можно воспользоваться функцией hypot из модуля math. Берется сумма квадратов аргументов функции, из нее получается корень. Аргументов у функции два.

from math import hypot
x = hypot(4,3)
print(x)

5.0

Еще одним, чуть более универсальным методом, будет использование возведения в степень. Известно, что для того, чтобы взять корень n из числа, необходимо возвести его в степень 1/n. Соответственно, извлечение квадратного корня из числа 4 будет выглядеть так:

n = 2
x = 4**(1./n)
print(x)

2.0

Обратите внимание, что в Python 2 необходимо ставить точку после единицы, иначе произойдет целочисленное деление, и 1/n == 0, а не нужной нам дроби. В Python 3 можно не ставить точку.. Последний метод использует функцию pow(value, n)

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

Последний метод использует функцию pow(value, n). Эта функция в качестве аргумента value возьмет число, которое необходимо возвести в степень, а второй аргумент будет отвечать за степень числа. Как и в предыдущем методе, необходимо использовать дробь, для того, чтобы получить корень числа.

x = pow(4, 0.5)
print(x)

2.0

Какой метод быстрее?

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

from time import monotonic
from math import sqrt
iterations = 1000000
start = monotonic()
for a in range(iterations):
    x = sqrt(4)
print("sqrt time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = 4 ** 0.5
print("** time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = pow(4, 0.5)
print("pow time: {:>.3f}".format(monotonic() - start) + " seconds")

sqrt time: 0.266 seconds
** time: 0.109 seconds
pow time: 0.453 seconds

Как видно, самое быстрое решение – использовать **. На втором месте метод sqrt, а pow – самый медленный. Правда, метод sqrt наиболее нагляден при вычислении в Python квадратных корней.

Таким образом, если критична скорость, то используем **. Если скорость не критична, а важна читаемость кода, то следует использовать sqrt.

Способы округления чисел

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

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

math.ceil() – округление чисел в большую сторону

Функция получила своё имя от термина «ceiling», который используется в математике для описания числа, которое больше или равно заданному.

Любая дробь находится в целочисленном интервале, например, 1.2 лежит между 1 и 2. Функция определяет, какая из границ интервала наибольшая и записывает её в результат округления.

Пример:

math.ceil(5.15) # = 6
math.ceil(6.666) # = 7
math.ceil(5) # = 5

Важно помнить, что функция определяет наибольшее число с учётом знака. То есть результатом округления числа -0.9 будет 0, а не -1.

math.floor() – округление чисел в меньшую сторону

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

Пример:

math.floor(7.9) # = 7
math.floor(9.999) # = 9
math.floor(-6.1) # = -7

math.trunc() – отбрасывание дробной части

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

Примеры:

math.trunc(5.51) # = 5
math.trunc(-6.99) # = -6

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

Примеры:

int(5.51) # = 5
int(-6.99) # = -6

Нормальное округление

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

И хотя работает по другому алгоритму, результат её использования для положительных чисел полностью аналогичен выводу функции floor(), которая округляет числа «вниз». Для отрицательных аналогичен функции ceil().

Примеры:

math.floor(9.999) # = 9
int(9.999) # = 9
math.ceil(-9.999) # = -9
int(-9.999) # = -9

Чтобы с помощью функции int() округлить число по математическим правилам, необходимо добавить к нему 0.5, если оно положительное, и -0.5, если оно отрицательное.

Тогда операция принимает такой вид: int(num + (0.5 if num > 0 else -0.5)). Чтобы каждый раз не писать условие, удобно сделать отдельную функцию:

def int_r(num):
    num = int(num + (0.5 if num > 0 else -0.5))
    return num

Функция работает также, как стандартная функция округление во второй версии Python (арифметическое округление).

Примеры:

int_r(11.5) # = 12
int_r(11.4) # = 11
int_r(-0.991) # = -1
int_r(1.391) # = 1

round() – округление чисел

round() – стандартная функция округления в языке Python. Она не всегда работает так, как ожидается, а её алгоритм различается в разных версиях Python.

В Python 2

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

Увеличение погрешности вызвано неравным количеством цифр, определяющих, в какую сторону округлять. Всего 4 цифры на конце приводят к округлению «вниз», и 5 цифр к округлению «вверх».

Помимо этого, могут быть неточности, например, если округлить число 2.675 до второго знака, получится число 2.67 вместо 2.68. Это происходит из-за невозможности точно представить десятичные числа типа «float» в двоичном коде.

В Python 3

В третьей версии Python используется банковское округление. Это значит, что округление происходит до самого близкого чётного.

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

Примеры:

round(3.5) # = 4
round(9.5) # = 10
round(6.5) # = 6
round(-6.5) # = -6
round(-7.5) # = -8

Но если вам по каким то причинам нужно округление как в Python 2, то можно воспользоваться функцией написанной нами выше на основе приведения к целому числу.

Округление до сотых

У функции есть ещё один аргумент. Он показывает до какого количества знаков после запятой следует округлять. Таким образом, если нам надо в Python округлить до сотых, этому параметру следует задать значение 2.

Пример округления до нужного знака:

round(3.555, 2) # = 3.56
round(9.515,1) # = 9.5
round(6.657,2) # = 6.66

Логические побитовые операции

Фактически, если число можно перевести в двоичную систему счисления, значит его можно рассматривать как двоичные данные. Учитывая, что такие данные состоят из нулей и единиц, которые интерпретируются как логические значения True и False, мы можем выполнять над ними логические операции. Логические операции выполняются по отдельным битам соответствующих разрядов. Если в операции учавствуют числа с разным количеством разрядов, то недостающие разряды дополняются нулями слева.

Данные операции могут быть выполнены, только над целыми числами. Если в выражении или в результате операции имеются отрицательные числа, то они представляются в виде дополнительного кода. Например, мы знаем, что результатом логического оператора (побитовое НЕ) примененного, скажем, к числу должно быть число , но вместо этого мы видим число дополнительный код которого соответствует данной операции:

В таблице перечислены все побитовые операции в порядке убывания их приоритета:

№	Операция	Результат	Замечание
1		инвертирование битов x	(I)
2		сдвиг битов числа x вправо на n разрядов	(II)(III)
3		сдвиг битов числа x влево на n разрядов	(II)(IV)
4		побитовое И чисел x и y
5		побитовое исключающее ИЛИ чисел x и y
6		побитовое ИЛИ чисел x и y

Важно: приоритет побитовых операций ниже математически, но выше операций сравнения.

Замечания:

I. унарные операции , и имеют одинаковый приоритет.

II. отрицательное значение в выражеиях и приведет к ошибке и вызовет исключение ValueError.

III. операция эквивалентна команде , но проверка переполнения в этой команде не выполняется:

IV. операция эквивалентна команде , но проверка переполнения в этой команде не выполняется:

Операторы Python

Оператор – это символ или функция, которая выполняет то или иное действие над данными. К примеру, символ + — это оператор сложения.

В Python присутствуют как общие, так и специальные математические операторы.

Ниже приведена таблица наиболее распространённых математических операторов Python.

Операция	Результат
x + y	Сложение (сумма x и y)
x — y	Вычитание (разница между x и y)
-x	Смена знака x
+x	Тождественность x
x * y	Умножение x на y
x / y	Деление x на y
x // y	Получение целой части от деления x на y
x % y	Остаток от деления x / y
x ** y	Возведение в степень

Также руководство охватывает использование операторов присваивания.

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

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)

Результат:

Задания для самоподготовки

1. Реализовать
последний вариант алгоритма Евклида с помощью рекурсивной функции.

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

arg1, arg2, …, argN

3. Реализовать
универсальную функцию для нахождения максимального или минимального значения
среди аргументов:

arg1, arg2, …, argN

с помощью
функции-селектора, указанной в виде лямбда-функции как один параметров функции
поиска.

Видео по теме

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, примеры использования

Копирование

• Определяет поведение для экземпляра вашего класса. возвращает поверхностную копию вашего объекта — это означает, что хоть сам объект и создан заново, все его данные ссылаются на данные оригинального объекта. И при изменении данных нового объекта, изменения будут происходить и в оригинальном.

• Определяет поведение для экземпляров вашего класса. возвращает глубокую копию вашего объекта — копируются и объект и его данные. это кэш предыдущих скопированных объектов, он предназначен для оптимизации копирования и предотвращения бесконечной рекурсии, когда копируются рекурсивные структуры данных. Когда вы хотите полностью скопировать какой-нибудь конкретный атрибут, вызовите на нём с первым параметром .