
Ще ползвате ли Quaternion.e
, Quaternion.i
,
Quaternion.j
, Quaternion.k
преди да създадете поне
една инстанция от класа?
Ще ползвате ли Quaternion.e
, Quaternion.i
,
Quaternion.j
, Quaternion.k
преди да създадете поне
една инстанция от класа?
Сега, след като вече попита, по всяка вероятност ще добавят и таткъв тест. =-)
Иначе, няма причина Quaternion.*
да не работят преди да е била
създадена инстанция.
Ще ползвате ли
Quaternion.e
,Quaternion.i
,Quaternion.j
,Quaternion.k
преди да създадете поне една инстанция от класа?
Не бива да разчиташ на това.
Единственото, което ти се гарантира, е че преди да викаме каквото и да е ще сме заредили изцяло модула ти.
За да работи Quaternion() == False, __nonzero__ ли трябва да предефинираме?
Метода, който връща булева стойност е __bool__
Обектът със __setattr__ ли се прави immutable, че при мен нещо не се получава?
За да работи Quaternion() == False, __nonzero__ ли трябва да предефинираме?
Няма няма да го сравняваме директно с bool
, но ще има
"cast-ване" до bool
и след това сравняване (образно казано).
С други думи може да има разни неща от рода на False ==
bool(Quaternion())
или if Quaternion(): ...
, но не и
Quaternion() == False
Също така метода е __bool__
, __nonzero__
е от
python < 3.
Обектът със __setattr_ ли се прави immutable, че при мен нещо не се получава?
Реално от вас се иска да симулирате immutability....
__setattr_
е с 2 _
накрая, т.е.
__setattr__
Това най-последното:
tuple - Създава n-торка от координатите на кватерниона tuple(Quaternion(1, 2, 3, 4)) # (1, 2, 3, 4)
Тук трябва да предефинираме __tuple__ , или няма изобщо такова?
Няма (нужда от) такова. Quaternion(1, 2, 3, 4).tuple() и tuple(Quaternion(1, 2, 3, 4)) използват един и същи метод и съответно резултатът им е един и същ.
И аз си мислех че има __tuple__, но се оказа че всъщност няма (изненада). Идеята за tuple(X) е обяснена в последната лекция (и не само за tuple(X), но и за set, list и всичко по което може да се итерира).
OK тогава, ама защо са написани на отделни места, трябва да има някаква уловка :P Aааааа, последната лекция. Кой е подозирал че ще се стигне до там :)
Няма (нужда от) такова. Quaternion(1, 2, 3, 4).tuple() и tuple(Quaternion(1, 2, 3, 4)) използват един и същи метод и съответно резултатът им е един и същ.
HELL NO! (Резултатът че им е един и същ е така, но не са един и същ метод,
т.е. ако имате q.tuple()
, не значи че ще работи
tuple(q)
)
Тук трябва да предефинираме __tuple__ , или няма изобщо такова?
Няма __tuple__
(т.е. можеш да си го напишеш, но
tuple(q)
няма да работи)
И да виж итератори
А, мерси много. Ей това е отговор. Че ми писна да чета някакви работи, на някои дето се правят на много разбиращи
Хехех.. Съгласен съм. Още един аргумент, защо освен палчета, трябва да се добавят и средни пръстчета във форума.
В момента грешния пост на Николай Беличев е с палче. Едно средно пръстче би могло да го неутрализира... =-)
Хаха, е аз значи да дигна курбан, че при мен си работи.
П.П. Мда, сега тествах, връщам си думите за това, че ползват един метод. Само q.tuple() го ползва. tuple(q), работи по друга причина.
Добра работа!
Само дето работи по съвсем друга причина (виж какво каза Точо). За да си
убеден, обаче, сложи един print
в Quaternion.tuple()
и
виж дали като извикаш tuple(Quaternion())
ще се изпълни.
А трябва ли да предефинираме __iadd__ например? Ще има ли неща от вида:
q = Quaternion(42,42,42,42)
q += Quaternion(3,3,3,3)
Няма такова нещо в условието, но все пак да питам :)
П.П. Я, то си работело и само, няма значение :) П.П.П. Добре, че няма средни пръстчета :P
Не е добра идея, предполага се, че обекта е "immutable".
и int
е immutable, но a += 1
работи :)
интересно дали са го направили с __iadd__ :)
Имам някви предположения че не са :D
>>> "__iadd__" in dir(int)
False
Здравейте!
Искам да попитам каква е разликата между атрибутите "e" и "scalar"?
q = Quaternion(1, 2, 3, 4)
(q.e, q.i, q.j, q.k) # (1, 2, 3, 4)
Quaternion(1, 2, 3, 4).scalar # 1
Според мен правят едно и също нещо. Моля, обяснете ми, ако бъркам! Мерси :)
Да, връщат една и съща стойност.
А трябва ли да предефинираме __iadd__ например? Ще има ли неща от вида:
q = Quaternion(42,42,42,42)
q += Quaternion(3,3,3,3)
Не е добра идея, предполага се, че обекта е "immutable".
Зависи как си предефинирал __add__. При прилагането "на място" не се модифицира обекта (правилото да е "immutable" е спазено), а се създава нов, който е резултат от съответната операция, т.е.
"При a OP= b и недефиниран __iOP__ се извиква a = a OP b"