With a list literal, the VM creates the list with a set length. When passing a sequence to the `list()` constructor the elements are added one by one (via &lt;a href=&quot;https://hg.python.org/releasing/3.4.2/file/10298f4f42dc/Objects/listobject.c#l781&quot;&gt;`list.extend()`&lt;/a&gt;) and as such the list is resized when appropriate. Since the &lt;a href=&quot;https://hg.python.org/releasing/3.4.2/file/10298f4f42dc/Objects/listobject.c#l25&quot;&gt;resize operation&lt;/a&gt; overallocates in order to amortize the cost, the final list will usually be larger than the source list.

When you create a list literal, the size reported is the minimum size needed to hold the data.  You can see this because the size jumps up if you append a single element.  However, when you use `list` to copy it, it allocates some extra space - it takes a few appends before it reallocates (in your case, I suspect the 8th append will do it - it needs 4 more bytes per element).  There is probably a reason why these allocation behaviors are different, but I&#39;m not sure what that might be.

I want to use the facebook share plugin for the web app I am working on, I only need the basic share button. The app uses requirejs for loading javascript, so I followed the [how-to](https://developers.facebook.com/docs/javascript/howto/requirejs) and changed the facebook api url to the one found in code snippets on facebook [docs](https://developers.facebook.com/docs/plugins/share-button/). This doesn&#39;t work and the sdk throws error ```invalid version specified```. This is how my files look.

__```main.js```__

    require.config({
      shim: {
        &#39;facebookshare&#39; : {
          exports: &#39;FB&#39;
        }
      },
      paths: {
        &#39;facebookshare&#39;:  &quot;//connect.facebook.net/en_US/sdk.js#xfbml=1&amp;version=v2.0&quot;
     }
    });
    require([&#39;fb&#39;]);

__```fb.js```__

    define([&#39;facebookshare&#39;], function(facebook) {
       document.body.innerHTML += &#39;&lt;div class=&quot;fb-share-button&quot; data-href=&quot;https://developers.facebook.com/docs/plugins/&quot; data-layout=&quot;button&quot;&gt;&lt;/div&gt;&#39;;
    });

What is the best way of including only the facebook share plugin with requirejs?

I referred following questions, but none of them provide a concrete solution. [Uncaught error: no version specified](https://stackoverflow.com/questions/23668541/uncaught-error-no-version-specified-facebook-sdk) and [wrong version error](https://stackoverflow.com/questions/24019877/fb-init-function-gives-wrong-version-error).

Invalid version specified, facebook share plugin error

Can somebody please elaborate on the difference between `aria-live=&quot;assertive&quot;` and `aria-live=&quot;polite&quot;`?

As per my understanding `aria-live=&quot;assertive&quot;` will get the higher priority and wipe off the queue, whereas `aria-live=&quot;polite&quot;` is having low priority over `aria-live=&quot;assertive&quot;` and will continue with queue.

Difference between aria-live=&quot;assertive&quot; and aria-live=&quot;polite&quot;

I&#39;m seeing some inconsistencies when using `sys.getsizeof` on what should be identical lists. (Python 2.7.5)

    &gt;&gt;&gt; lst = [0,1,2,3,4,5,6,7,8,9]
    &gt;&gt;&gt; sys.getsizeof(lst)
    76
    &gt;&gt;&gt; lst2 = list(lst)
    &gt;&gt;&gt; sys.getsizeof(lst2)
    104
    &gt;&gt;&gt; lst3 = list(lst2)
    &gt;&gt;&gt; sys.getsizeof(lst3)
    104
    &gt;&gt;&gt; sys.getsizeof(lst[:])
    76
    &gt;&gt;&gt; sys.getsizeof(lst2[:])
    76

Does anybody have a simple explanation?


Why does creating a list from a list make it larger?

I'm seeing some inconsistencies when using <code>sys.getsizeof</code> on what should be identical lists. (Python 2.7.5)
<pre><code class="hljs language-python-repl">>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> sys.getsizeof(lst)
76
>>> lst2 = list(lst)
>>> sys.getsizeof(lst2)
104
>>> lst3 = list(lst2)
>>> sys.getsizeof(lst3)
104
>>> sys.getsizeof(lst[:])
76
>>> sys.getsizeof(lst2[:])
76
</code></pre>
Does anybody have a simple explanation?

**Situation**

While working with validation in the Django REST Framework&#39;s `ModelSerializer`, I have noticed that the `Meta.model` fields are always validated, even when it does not necessarily make sense to do so. Take the following example for a `User` model&#39;s serialization:

 1. I have an endpoint that creates a user. As such, there is a `password` field and a `confirm_password` field. If the two fields do not match, the user cannot be created. Likewise, if the requested `username` already exists, the user cannot be created.
 2. The user POSTs improper values for each of the fields mentioned above
 2. An implementation of `validate` has been made in the serializer (see below), catching the non-matching `password` and `confirm_password` fields

Implementation of `validate`:

    def validate(self, data):
        if data[&#39;password&#39;] != data.pop(&#39;confirm_password&#39;):
            raise serializers.ValidationError(&quot;Passwords do not match&quot;)
        return data

**Problem**

Even when the `ValidationError` is raised by `validate`, the `ModelSerializer` still queries the database to check to see if the `username` is already in use. This is evident in the error-list that gets returned from the endpoint; both the model and non-field errors are present.

Consequently, I would like to know how to prevent model validation until after non-field validation has finished, saving me a call to my database.

**Attempt at solution**

I have been trying to go through the DRF&#39;s source to figure out where this is happening, but I have been unsuccessful in locating what I need to override in order to get this to work.

Order of Serializer Validation in Django REST Framework

I have a pandas series `series`.  If I want to get the element-wise floor or ceiling, is there a built in method or do I have to write the function and use apply?  I ask because the data is big so I appreciate efficiency.  Also this question has not been asked with respect to the Pandas package. 

Floor or ceiling of a pandas series in python?

I try to convert matlab code to numpy and figured out that numpy has a different result with the std function.

in matlab

    std([1,3,4,6])
    ans =  2.0817

in numpy

    np.std([1,3,4,6])
    1.8027756377319946

Is this normal? And how should I handle this?

Why does numpy std() give a different result to matlab std()?

I am having hard time parsing the arguments to subprocess.Popen.  I am trying to execute a script on my Unix server. The script syntax when running on shell prompt is as follows:
`/usr/local/bin/script hostname = &lt;hostname&gt; -p LONGLIST`. No matter how I try, the script is not running inside subprocess.Popen

The space before and after &quot;=&quot; is mandatory.

    import subprocess
    Out = subprocess.Popen([&#39;/usr/local/bin/script&#39;, &#39;hostname = &#39;, &#39;actual server name&#39;, &#39;-p&#39;, &#39;LONGLIST&#39;],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)

The above does not work.

And when I use shell=False, I get `OSError: [Errno 8] Exec format error`




OSError: [Errno 8] Exec format error

Is it possible to check [argparse choices][1] in case-insensitive manner?

    import argparse
    choices = [&quot;win64&quot;, &quot;win32&quot;]
    parser = argparse.ArgumentParser()
    parser.add_argument(&quot;-p&quot;, choices=choices)
    print(parser.parse_args([&quot;-p&quot;, &quot;Win32&quot;]))

results in:

    usage: choices.py [-h] [-p {win64,win32}]
    choices.py: error: argument -p: invalid choice: &#39;Win32&#39; (choose from &#39;win64&#39;,&#39;win32&#39;)

  [1]: https://docs.python.org/3/library/argparse.html#choices

Case insensitive argparse choices

Say I have the list `score = [1,2,3,4,5]` and it gets changed while my program is running. How could I save it to a file so that next time the program is run I can access the changed list as a `list` type? 

I have tried:

    score=[1,2,3,4,5]

    with open(&quot;file.txt&quot;, &#39;w&#39;) as f:
        for s in score:
            f.write(str(s) + &#39;\n&#39;)

    with open(&quot;file.txt&quot;, &#39;r&#39;) as f:
        score = [line.rstrip(&#39;\n&#39;) for line in f]


    print(score)

But this results in the elements in the list being strings not integers.

How to save a list to a file and read it as a list type?

I have the following controller method:

	@RequestMapping(value=&quot;/map/update&quot;, method=RequestMethod.POST, produces = &quot;application/json; charset=utf-8&quot;)
	@ResponseBody
	public ResponseEntityWrapper updateMapTheme(
			HttpServletRequest request, 
			@RequestBody @Valid List&lt;CompanyTag&gt; categories,
			HttpServletResponse response
			) throws ResourceNotFoundException, AuthorizationException {
    ...
    }

CompanyTag is defined this way:

    public class CompanyTag {
        @StringUUIDValidation String key;
    	String value;
    	String color;
    	String icon;
    	Icon iconObj;
    	
    	public String getKey() {
    		return key;
    	}
    	
    	public void setKey(String key) {
    		this.key = key;
    	}
       ...
    }

The problem is that validation is not triggered, the CompanyTag list is not validated, the &quot;StringUUIDValidation&quot; validator is never called.  

If I remove the List and only try to send a single CompanyTag, i.e. instead of:

	@RequestBody @Valid List&lt;CompanyTag&gt; categories,
use:

	@RequestBody @Valid CompanyTag category,

 it works as expected, so apparently Spring does not like to validate lists of things (tried with array instead, that did not work either). 

Anybody have any idea what&#39;s missing?

Validation of a list of objects in Spring

I have a list of tuples similar to the below:

    [(date1, ticker1, value1),(date1, ticker1, value2),(date1, ticker1, value3)]

I want to convert this to a DataFrame with `index=date1`, `columns=ticker1`, and `values = values`.  What is the best way to do this?

EDIT:

My end goal is to create a DataFrame with a datetimeindex equal to date1 with values in a column labeled &#39;ticker&#39;:

    df = pd.DataFrame(tuples, index=date1)

Right now the tuple is generated with the following:

    tuples=list(zip(*prc_path))

where prc_path is a numpy.ndarray with shape (1000,1)




List of Tuples to DataFrame Conversion

I have a list of dictionaries and each dictionary has a key of (let&#39;s say) &#39;type&#39; which can have values of `&#39;type1&#39;`, `&#39;type2&#39;`, etc. My goal is to filter out these dictionaries into a list of the same dictionaries but only the ones of a certain &quot;type&quot;. I think i&#39;m just really struggling with `list/dictionary` comprehensions. 

so an example list would look like:

    exampleSet = [{&#39;type&#39;:&#39;type1&#39;},{&#39;type&#39;:&#39;type2&#39;},{&#39;type&#39;:&#39;type2&#39;}, {&#39;type&#39;:&#39;type3&#39;}]

i have a list of key values. lets say for example: 
    
    keyValList = [&#39;type2&#39;,&#39;type3&#39;]

where the expected resulting list would look like: 

    expectedResult = [{&#39;type&#39;:&#39;type2&#39;},{&#39;type&#39;:&#39;type2&#39;},{&#39;type&#39;:&#39;type3&#39;}]

I know i could do this with a set of for loops. I know there has to be a simpler way though. i found a lot of different flavors of this question but none that really fit the bill and answered the question. I would post an attempt at the answer... but they weren&#39;t that impressive. probably best to leave it open ended. any assistance would be greatly appreciated. 


python filter list of dictionaries based on key value

I have this list (`List&lt;String&gt;`):

    [&quot;a&quot;, &quot;b&quot;, null, &quot;c&quot;, null, &quot;d&quot;, &quot;e&quot;]

And I&#39;d like something like this:

    [[&quot;a&quot;, &quot;b&quot;], [&quot;c&quot;], [&quot;d&quot;, &quot;e&quot;]]

In other words I want to split my list in sublists using the `null` value as separator, in order to obtain a list of lists (`List&lt;List&lt;String&gt;&gt;`). I&#39;m looking for a Java 8 solution. I&#39;ve tried with `Collectors.partitioningBy` but I&#39;m not sure it is what I&#39;m looking for. Thanks!

Splitting List into sublists along elements

    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; in (&#39;x&#39;,)&quot;)
    0.04869917374131205
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; == &#39;x&#39;&quot;)
    0.06144205736110564

Also works for tuples with multiple elements, both versions seem to grow linearly:

    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; in (&#39;x&#39;, &#39;y&#39;)&quot;)
    0.04866674801541748
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; == &#39;x&#39; or &#39;x&#39; == &#39;y&#39;&quot;)
    0.06565782838087131
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; in (&#39;y&#39;, &#39;x&#39;)&quot;)
    0.08975995576448526
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; == &#39;y&#39; or &#39;x&#39; == &#39;y&#39;&quot;)
    0.12992391047427532

Based on this, I think I should *totally* start using `in` everywhere instead of `==`!

Why is &#39;x&#39; in (&#39;x&#39;,) faster than &#39;x&#39; == &#39;x&#39;?


It is my understanding that the `range()` function, which is actually [an object type in Python 3][1], generates its contents on the fly, similar to a generator.

This being the case, I would have expected the following line to take an inordinate amount of time because, in order to determine whether 1 quadrillion is in the range, a quadrillion values would have to be generated:

    1_000_000_000_000_000 in range(1_000_000_000_000_001)

Furthermore: it seems that no matter how many zeroes I add on, the calculation more or less takes the same amount of time (basically instantaneous).

I have also tried things like this, but the calculation is still almost instant:

    # count by tens
    1_000_000_000_000_000_000_000 in range(0,1_000_000_000_000_000_000_001,10)

If I try to implement my own range function, the result is not so nice!

    def my_crappy_range(N):
        i = 0
        while i &lt; N:
            yield i
            i += 1
        return

What is the `range()` object doing under the hood that makes it so fast?

----------

[Martijn Pieters&#39;s answer][2] was chosen for its completeness, but also see [abarnert&#39;s first answer][3] for a good discussion of what it means for `range` to be a full-fledged *sequence* in Python 3, and some information/warning regarding potential inconsistency for `__contains__` function optimization across Python implementations. [abarnert&#39;s other answer][4] goes into some more detail and provides links for those interested in the history behind the optimization in Python 3 (and lack of optimization of `xrange` in Python 2). Answers [by poke][5] and [by wim][6] provide the relevant C source code and explanations for those who are interested. 

  [1]: https://docs.python.org/3/library/stdtypes.html#typesseq-range
  [2]: https://stackoverflow.com/a/30081318/2437514
  [3]: https://stackoverflow.com/a/30081894/2437514
  [4]: https://stackoverflow.com/a/30088140/2437514
  [5]: https://stackoverflow.com/a/30081467/2437514
  [6]: https://stackoverflow.com/a/30081470/2437514

Why is &quot;1000000000000000 in range(1000000000000001)&quot; so fast in Python 3?

When comparing floats to integers, some pairs of values take much longer to be evaluated than other values of a similar magnitude.

For example:

    &gt;&gt;&gt; import timeit
    &gt;&gt;&gt; timeit.timeit(&quot;562949953420000.7 &lt; 562949953421000&quot;) # run 1 million times
    0.5387085462592742

But if the float or integer is made smaller or larger by a certain amount, the comparison runs much more quickly:

    &gt;&gt;&gt; timeit.timeit(&quot;562949953420000.7 &lt; 562949953422000&quot;) # integer increased by 1000
    0.1481498428446173
    &gt;&gt;&gt; timeit.timeit(&quot;562949953423001.8 &lt; 562949953421000&quot;) # float increased by 3001.1
    0.1459577925548956

Changing the comparison operator (e.g. using `==` or `&gt;` instead) does not affect the times in any noticeable way. 

This is not *solely* related to magnitude because picking larger or smaller values can result in faster comparisons, so I suspect it is down to some unfortunate way the bits line up. 

Clearly, comparing these values is more than fast enough for most use cases. I am simply curious as to why Python seems to struggle more with some pairs of values than with others.

Why are some float &lt; integer comparisons four times slower than others?

Surprisingly, I find `startswith` is slower than `in`:

    In [10]: s=&quot;ABCD&quot;*10

    In [11]: %timeit s.startswith(&quot;XYZ&quot;)
    1000000 loops, best of 3: 307 ns per loop
    
    In [12]: %timeit &quot;XYZ&quot; in s
    10000000 loops, best of 3: 81.7 ns per loop

As we all know, the `in` operation needs to search the whole string and `startswith` just needs to check the first few characters, so `startswith` should be more efficient.

When `s` is big enough, `startswith` is faster:

    In [13]: s=&quot;ABCD&quot;*200
    
    In [14]: %timeit s.startswith(&quot;XYZ&quot;)
    1000000 loops, best of 3: 306 ns per loop
    
    In [15]: %timeit &quot;XYZ&quot; in s
    1000000 loops, best of 3: 666 ns per loop

So it seems that calling `startswith` has some overhead which makes it slower when the string is small.

And than I tried to figure out what&#39;s the overhead of the `startswith` call.
    
First, I used an `f` variable to reduce the cost of the dot operation - as mentioned in this [answer][1] - here we can see `startswith` is still slower:

    In [16]: f=s.startswith
    
    In [17]: %timeit f(&quot;XYZ&quot;)
    1000000 loops, best of 3: 270 ns per loop

Further, I tested the cost of an empty function call:

    In [18]: def func(a): pass
    
    In [19]: %timeit func(&quot;XYZ&quot;)
    10000000 loops, best of 3: 106 ns per loop

Regardless of the cost of the dot operation and function call, the time of `startswith` is about (270-106)=164ns, but the `in` operation takes only 81.7ns. It seems there are still some overheads for `startswith`, what&#39;s that?

Add the test result between `startswith` and `__contains__` as suggested by poke and lvc:

    In [28]: %timeit s.startswith(&quot;XYZ&quot;)
    1000000 loops, best of 3: 314 ns per loop
    
    In [29]: %timeit s.__contains__(&quot;XYZ&quot;)
    1000000 loops, best of 3: 192 ns per loop


  [1]: https://stackoverflow.com/a/13271125/552942

Why is string&#39;s startswith slower than in?

The complexity of `len()` with regards to sets and lists is equally O(1). How come it takes more time to process sets?

    ~$ python -m timeit &quot;a=[1,2,3,4,5,6,7,8,9,10];len(a)&quot;
    10000000 loops, best of 3: 0.168 usec per loop
    ~$ python -m timeit &quot;a={1,2,3,4,5,6,7,8,9,10};len(a)&quot;
    1000000 loops, best of 3: 0.375 usec per loop

Is it related to the particular benchmark, as in, it takes more time to build sets than lists and the benchmark takes that into account as well?

If the creation of a set object takes more time compared to creating a list, what would be the underlying reason?

Content Type	Original Author	Original Content on Stackoverflow
Question	Mark Ransom	View Question on Stackoverflow
Solution 1 - Python	Ignacio Vazquez-Abrams	View Answer on Stackoverflow
Solution 2 - Python	Aaron Dufour	View Answer on Stackoverflow

Why does creating a list from a list make it larger?

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Difference between aria-live="assertive" and aria-live="polite"

Invalid version specified, facebook share plugin error

Attributions