cpython

In Python (2 and 3). Whenever we use list slicing it returns a new object, e.g.: l1 = [1,2,3,4] print(id(l1)) l2 = l1[:] print(id(l2)) Output >>> 140344378384464 >>> 140344378387272 If the same thing is repeated with tuple, the same object is returned, e.g.: t1 = (1,2,3,4) t2 = t1[:] print(id(t1)) print(id(t2)) Output >>> 140344379214896 >>> 140344379214896 It would be great if someone can shed some light on why this is happening, throughout my Python experience I was under the impression empty slice returns a new object. My understanding is that it's returning the same object as tuples are

I notice a case in python, when a block of code, nested in a loop, runs continuously, it is much faster than running with some .sleep() time interval. I wonder the reason and a possible solution . I guess it's related to CPU-cache or some mechanism of cPython VM. ''' Created on Aug 22, 2015 @author: doge ''' import numpy as np import time import gc gc.disable() t = np.arange(100000) for i in xrange(100): #np.sum(t) time.sleep(1) #--> if you comment this line, the following lines will be much faster st = time.time() np.sum(t) print (time.time() - st)*1e6 result: without sleep in loop, time

Assume that we have a list of strings and we want to create a string by concatenating all element in this list. Something like this: def foo(str_lst): result = '' for element in str_lst: result += element return result Since strings are immutable objects, I expect that python creates a new str object and copy contents of result and element at each iteration. It makes O(M * N^2) time complexity, M is the length of each element and N is the size of the list. However, my experiment shows that it runs in linear time. N = 1000000 # 1 million str_lst = ['a' for _ in range(N)] foo(str_lst) # It takes

So recently I understand the concept of function closure. def outer(): somevar = [] assert "somevar" in locals() and not "somevar" in globals() def inner(): assert "somevar" in locals() and not "somevar" in globals() somevar.append(5) return somevar return inner function = outer() somevar_returned = function() assert id(somevar_returned) == id(function.func_closure[0].cell_contents) As much as I understand, the objective of function closure is to keep an active reference to the object, in order to avoid garbage collection of this object. This is why the following works fine : del outer somevar

In the python idle: >>> a=1.1 >>> b=1.1 >>> a is b False But when I put the code in a script and run it, I will get a different result: $cat t.py a=1.1 b=1.1 print a is b $python t.py True Why did this happen? I know that is compares the id of two objects, so why the ids of two objects are same/unique in python script/idle? I also found that, if I use a small int, for example 1 , instead of 1.1 , the result will be the same in both the python script and python idle. Why did small int and small float have different behavior? I am using CPython 2.7.5. poke When Python executes a script file, the

So it's a CPython thing, not quite sure that it has same behaviour with other implementations. But '{0}'.format() is faster than str() and '{}'.format() . I'm posting results from Python 3.5.2 , but, I tried it with Python 2.7.12 and the trend is the same. %timeit q=['{0}'.format(i) for i in range(100, 100000, 100)] %timeit q=[str(i) for i in range(100, 100000, 100)] %timeit q=['{}'.format(i) for i in range(100, 100000, 100)] 1000 loops, best of 3: 231 µs per loop 1000 loops, best of 3: 298 µs per loop 1000 loops, best of 3: 434 µs per loop From the docs on object.__str__(self) Called by str