python-internals

i can silence and restore sys.stdout this way: import sys sys.stdout = None print('hello') # does not write to stdout sys.stdout = sys.__stdout__ print('hello') # writes to stdout i know i'd better be using contextlib.redirect_stdout which probably does something similar but my question is: why does the above code work? i'd have assumed python would call things like sys.stdout.write() so whatever i replace sys.stdout with should have a write method (like e.g. io.StringIO ) at least. print has an explicit check for None . /* sys.stdout may be None when FILE* stdout isn't connected */ if (file =

If you run x = 'y' 'z' in Python, you get x set to 'yz' , which means that some kind of string concatenation is occurring when Python sees multiple strings next to each other. But what kind of concatenation is this? Is it actually running 'y' + 'z' or is it running ''.join('y','z') or something else? The Python parser interprets that as one string. This is well documented in the Lexical Analysis documentation : String literal concatenation Multiple adjacent string literals (delimited by whitespace), possibly using different quoting conventions, are allowed, and their meaning is the same as

Under Python 2.7.5 >>> import sys >>> sys.getrefcount(10000) 3 Where are the three refcount? PS: when the 10000 PyIntObject would be Py_DECREF to 0 ref and deallocated? Do not say about gc stuff, reference count itself can work without gc. When you do something in the REPL console, the string will be compiled internally and during the compilation process, Python creates an intermediate list with the list of strings apart from tokens. So, that is reference number 1. You can check this like this import gc print gc.get_referrers(10000) # [['sys', 'dis', 'gc', 'gc', 'get_referrers', 10000], (-1,

In this post , Guido van Rossum says that a function call may be expensive, but I do not understand why nor how much expensive can be. How much delay adds to your code a simple function call and why? A function call requires that the current execution frame is suspended, and a new frame is created and pushed on the stack. This is relatively expensive, compared to many other operations. You can measure the exact time required with the timeit module: >>> import timeit >>> def f(): pass ... >>> timeit.timeit(f) 0.15175890922546387 That's 1/6th of a second for a million calls to an empty function;

The Python Doc for Comparisons says: Comparisons can be chained arbitrarily, e.g., x < y <= z is equivalent to x < y and y <= z , except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false). And these SO questions/answers shed some more light on such usage: Python comparison operators chaining/grouping left to right? What does "evaluated only once" mean for chained comparisons in Python? , in particular the currently-accepted answer So something like (contrived example): if 1 < input("Value:") < 10: print "Is greater than 1 and less than

Python's magic method __call__ is called whenever you attempt to call an object. Cls()() is thus equal to Cls.__call__(Cls()) . Functions are first class objects in Python, meaning they're just callable objects (using __call__ ). However, __call__ itself is a function, thus it too has __call__ , which again has its own __call__ , which again has its own __call__ . So Cls.__call__(Cls()) is thus equal to Cls.__call__.__call__(Cls()) and again equilevant to Cls.__call__.__call__.__call__(Cls()) and so on and so forth. How does this infinite loop end? How does __call__ actually execute the code?

I'm learning Learn Python the hard way. w = "This is the left side of..." e = "a string with a right side." print w + e Explain why adding the two strings w and e with + makes a longer string. Even I know it can work, but I don't understand why and how? Please help me. Python uses + to concatenate strings because that's how core developers of Python defined that operator. While it's true that __add__ special method is normally used to implement the + operator, + ( BINARY_ADD bytecode instruction ) does not call str.__add__ because + treats strings specially in both Python 2 and Python 3.

In Python, dictionaries created for the instances of a class are tiny compared to the dictionaries created containing the same attributes of that class: import sys class Foo(object): def __init__(self, a, b): self.a = a self.b = b f = Foo(20, 30) When using Python 3.5.2, the following calls to getsizeof produce: >>> sys.getsizeof(vars(f)) # vars gets obj.__dict__ 96 >>> sys.getsizeof(dict(vars(f)) 288 288 - 96 = 192 bytes saved! Using Python 2.7.12, though, on the other hand, the same calls return: >>> sys.getsizeof(vars(f)) 280 >>> sys.getsizeof(dict(vars(f))) 280 0 bytes saved. In both cases