Uh oh!
There was an error while loading. Please reload this page.
bpo-35105: Document that CPython accepts "invalid" identifiers - #11263
bpo-35105: Document that CPython accepts "invalid" identifiers#11263Windsooon wants to merge 2 commits into
Conversation
terryjreedy
left a comment
There was a problem hiding this comment.
That you for proposing something specific to chew on. I think spelling, grammar, and content all need tweaking.
Uh oh!
There was an error while loading. Please reload this page.
bedevere-bot
commented
Dec 20, 2018
A Python core developer has requested some changes be made to your pull request before we can consider merging it. If you could please address their requests along with any other requests in other reviews from core developers that would be appreciated. Once you have made the requested changes, please leave a comment on this pull request containing the phrase |
zhangyangyu
commented
Dec 21, 2018
Do we really need to mention this? |
terryjreedy
commented
Dec 21, 2018
That discussion is on the issue. |
rhettinger
left a comment
There was a problem hiding this comment.
I don't think we can mark this as an implementation detail for setattr(). The details are downstream and determined by the target object, not by setattr itself.
Suggested wording:
Note, setattr() attempts to update the object with the given attr/value pair.
Whether this succeeds and what its affect is is determined by the target object.
If an object's class defines `__slots__`, the attribute may not be writeable.
If an object's class defines property with a setter method, the *setattr()*
will trigger the setter method which may or may not actually write the attribute.
For objects that have a regular dictionary (which is the typical case), the
*setattr()* call can make any string keyed update allowed by the dictionary
including keys that aren't valid identifiers -- for example setattr(a, '1', 'one')
will be the equivalent of vars()['1'] ='one'.
This issue has little to do with setattr() and is more related to the fact that instance dictionaries can hold any valid key. In a way, it is no different than a user writing a.__dict__['1'] = 'one'. That has always been allowed and the __dict__ attribute is documented as writeable, so a user is also allowed to write `a.dict = {'1': 'one'}.
In short, we can talk about this in the setattr() docs but it isn't really a setattr() issue. Also, the behavior is effectively guaranteed by the other things users are allowed to do, so there is no merit in marking this as an implementation detail. Non-identifier keys can make it into an instance dictionary via multiple paths that are guaranteed to work.
terryjreedy
commented
Dec 24, 2018
I agree with Raymond's revision. Note that it would replace the entire proposed addition, including the impl-detail directive. By adding more 'meat', it makes an addition more worthwhile. |
csabella
left a comment
There was a problem hiding this comment.
The whole note needs to be indented for proper alignment.
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
JulienPalard
commented
Sep 11, 2019
Hi @Windsooon thanks for this PR! Would you have some time to integrate Cheryl comments? |
Windsooon
commented
Sep 11, 2019
I just updated it. Thank you @csabella |
JulienPalard
left a comment
There was a problem hiding this comment.
LGTM with nits (all can be accepted right from github).
| .. note:: | ||
| setattr() attempts to update the object with the given attr/value pair. |
There was a problem hiding this comment.
| setattr() attempts to update the object with the given attr/value pair. | |
| ``setattr()`` attempts to update the object with the given attr/value pair. |
| setattr() attempts to update the object with the given attr/value pair. | ||
| Whether this succeeds and the effect it has determined by the target object. | ||
| If an object's class defines `__slots__`, the attribute may not be writeable. |
There was a problem hiding this comment.
| If an object's class defines `__slots__`, the attribute may not be writeable. | |
| If an object's class defines ``__slots__``, the attribute may not be writeable. |
| For objects that have a regular dictionary (which is the typical case), the | ||
| *setattr()* call can make any string keyed update allowed by the dictionary | ||
| including keys that aren't valid identifiers -- for example ``setattr(a, '1', 'one')`` | ||
| will be the equivalent of ``vars()['1'] ='one'``. |
There was a problem hiding this comment.
| will be the equivalent of ``vars()['1'] ='one'``. | |
| will be the equivalent of ``vars()['1'] ='one'``. |
csabella
commented
Jan 12, 2020
@Windsooon, please address the review comments from Julien. Thanks! |
AlexWaygood
commented
Apr 17, 2022
Changes were requested on this PR by a core dev over two years ago, but have not been applied. There is also now a merge conflict. I am therefore closing this PR. @Windsooon, if you're still interested in working on this, feel free to open a new PR. Alternatively, ping me, and I'll happily reopen the PR. Thanks! 🙂 |
Windsooon
commented
Apr 21, 2022
@AlexWaygood I'm so sorry for missing the notification from CPython, I will catch up in a few weeks. |
AlexWaygood
commented
Apr 21, 2022
@Windsooon no worries! |
| .. note:: | ||
| setattr() attempts to update the object with the given attr/value pair. |
There was a problem hiding this comment.
(in addition to the above)
| setattr() attempts to update the object with the given attr/value pair. | |
| setattr() attempts to update the object with the given attribute/value pair. |
or
| setattr() attempts to update the object with the given attr/value pair. | |
| setattr() attempts to update the object with the given attribute-value pair. |
| .. note:: | ||
| setattr() attempts to update the object with the given attr/value pair. | ||
| Whether this succeeds and the effect it has determined by the target object. |
There was a problem hiding this comment.
| Whether this succeeds and the effect it has determined by the target object. | |
| Whether this succeeds and the effect it has is determined by the target object. |
| setattr() attempts to update the object with the given attr/value pair. | ||
| Whether this succeeds and the effect it has determined by the target object. | ||
| If an object's class defines `__slots__`, the attribute may not be writeable. | ||
| If an object's class defines :class:`property` with a setter method, the *setattr()* |
There was a problem hiding this comment.
*setattr()* -> `setattr()` here and below (I think * is commonly used for parameters)
| will trigger the setter method which may or may not actually write the attribute. | ||
| For objects that have a regular dictionary (which is the typical case), the | ||
| *setattr()* call can make any string keyed update allowed by the dictionary | ||
| including keys that aren't valid identifiers -- for example ``setattr(a, '1', 'one')`` |
There was a problem hiding this comment.
Would you happen to have an example of this behavior? I'm not quite following what it's doing (how a turns into vars())
| If an object's class defines :class:`property` with a setter method, the *setattr()* | ||
| will trigger the setter method which may or may not actually write the attribute. | ||
| For objects that have a regular dictionary (which is the typical case), the | ||
| *setattr()* call can make any string keyed update allowed by the dictionary |
There was a problem hiding this comment.
| *setattr()* call can make any stringkeyed update allowed by the dictionary | |
| *setattr()* call can make any string-keyed update allowed by the dictionary |
AlexWaygood
commented
Oct 11, 2022
I think this PR has now been superseded by #96454 |
https://bugs.python.org/issue35105