python-internals

according to this guide on python descriptors https://docs.python.org/2/howto/descriptor.html method objects in new style classes are implemented using descriptors in order to avoid special casing them in attribute lookup. the way I understand this is that there is a method object type that implements __get__ and returns a bound method object when called with an instance and an unbound method object when called with no instance and only a class. the article also states that this logic is implemented in the object.__getattribute__ method. like so: def __getattribute__(self, key): "Emulate type

Consider the following example: i=7 j=8 k=10 def test(): i=1 j=2 k=3 return dict((name,eval(name)) for name in ['i','j','k']) It returns: >>> test() {'i': 7, 'k': 10, 'j': 8} Why eval does not take into consideration the variables defined inside the function? From the documentation, optionally you can pass a globals and a locals dictionary. What does it means?Finally, how can I modify this small case to make it work? Generators are implemented as function scopes : The scope of names defined in a class block is limited to the class block; it does not extend to the code blocks of methods – this

I understand that this could be argued as a non-issue, but I write software for HPC environments, so this 3.5x speed increase actually makes a difference. In [1]: %timeit 10 / float(98765) 1000000 loops, best of 3: 313 ns per loop In [2]: %timeit 10 / (98765 * 1.0) 10000000 loops, best of 3: 80.6 ns per loop I used dis to have a look at the code, and I assume float() will be slower as it requires a function call (unfortunately I couldn't dis.dis(float) to see what it's actually doing). I guess a second question would be when should I use float(n) and when should I use n * 1.0 ? thefourtheye

In Python, globals() returns a representation of the global symbol table, while locals() returns a representation of the local state. While both return a dictionary, changes to globals() are effected in the global symbol table, while change to locals() have no effect. Why is this the case? Function locals are highly optimised and determined at compile time, CPython builds on not being able to alter the known locals dynamically at runtime. You can see this when decoding a function bytecode: >>> import dis >>> def foo(): ... a = 'bar' ... return a + 'baz' ... >>> dis.dis(foo) 2 0 LOAD_CONST 1 (

Can anyone familiar with Python's internals (CPython, or other implementations) explain why list addition is required to be homogenous: In [1]: x = [1] In [2]: x+"foo" --------------------------------------------------------------------------- TypeError Traceback (most recent call last) C:\Users\Marcin\<ipython-input-2-94cd84126ddc> in <module>() ----> 1 x+"foo" TypeError: can only concatenate list (not "str") to list In [3]: x+="foo" In [4]: x Out[4]: [1, 'f', 'o', 'o'] Why shouldn't the x+"foo" above return the same value as the final value of x in the above transcript? This question follows

CPython has a strange behaviour where it sets modules to None during shutdown. This screws up error logging during shutdown of some multithreading code I've written. I can't find any documentation of this behaviour. It's mentioned in passing in PEP 432 : [...] significantly reducing the number of modules that will experience the "module globals set to None" behaviour that is used to deliberate break cycles and attempt to releases more external resources cleanly. There are SO questions about this behaviour and the C API documentation mentions shutdown behaviour for embedded interpreters . I've