python-internals

I created two lists l1 and l2 , but each one with a different creation method: import sys l1 = [None] * 10 l2 = [None for _ in range(10)] print('Size of l1 =', sys.getsizeof(l1)) print('Size of l2 =', sys.getsizeof(l2)) But the output surprised me: Size of l1 = 144 Size of l2 = 192 The list created with a list comprehension is a bigger size in memory, but the two lists are identical in Python otherwise. Why is that? Is this some CPython internal thing, or some other explanation? When you write [None] * 10 , Python knows that it will need a list of exactly 10 objects, so it allocates exactly

In Python 3, is a list comprehension simply syntactic sugar for a generator expression fed into the list function? e.g. is the following code: squares = [x**2 for x in range(1000)] actually converted in the background into the following? squares = list(x**2 for x in range(1000)) I know the output is identical, and Python 3 fixes the surprising side-effects to surrounding namespaces that list comprehensions had, but in terms of what the CPython interpreter does under the hood, is the former converted to the latter, or are there any difference in how the code gets executed? Background I found

I'm wondering how is the new super in Python 3 implemented. This question was born in my head after I have made a small example and I got a strange error. I'm using Pyutilib Component architecture (PCA) and I've made my custom metaclass to drive the creation of another class: from pyutilib.component.core import implements, SingletonPlugin, PluginMeta, Interface class IPass(Interface): pass class __MetaPlugin(PluginMeta): def __new__(cls, name, baseClasses, classdict): print(cls, name, baseClasses, classdict) if baseClasses: baseClasses += (SingletonPlugin,) return PluginMeta.__new__(cls, name,

Here is my code: from memory_profiler import profile @profile def mess_with_memory(): huge_list = range(20000000) del huge_list print "why this kolaveri di?" This is what the output is, when I ran it from interpreter: Line # Mem usage Increment Line Contents 3 7.0 MiB 0.0 MiB @profile 4 def mess_with_memory(): 5 6 628.5 MiB 621.5 MiB huge_list = range(20000000) 7 476.0 MiB -152.6 MiB del huge_list 8 476.0 MiB 0.0 MiB print "why this kolaveri di" If you notice the output, creating the huge list consumed 621.5 MB while deleting it just freed up 152.6 MB. When i checked the docs , I found the

My limited brain cannot understand why this happens: >>> print '' in 'lolsome' True In PHP, a equivalent comparison returns false: var_dump(strpos('', 'lolsome')); From the documentation : For the Unicode and string types, x in y is true if and only if x is a substring of y . An equivalent test is y.find(x) != -1 . Note, x and y need not be the same type; consequently, u'ab' in 'abc' will return True . Empty strings are always considered to be a substring of any other string, so "" in "abc" will return True . From looking at your print call, you're using 2.x. To go deeper, look at the bytecode

We all know that eval is dangerous , even if you hide dangerous functions, because you can use Python's introspection features to dig down into things and re-extract them. For example, even if you delete __builtins__ , you can retrieve them with [c for c in ().__class__.__base__.__subclasses__() if c.__name__ == 'catch_warnings'][0]()._module.__builtins__ However, every example I've seen of this uses attribute access. What if I disable all builtins, and disable attribute access (by tokenizing the input with a Python tokenizer and rejecting it if it has an attribute access token)? And before