`None` is allowed because `numpy.newaxis` is merely an alias for `None`.

    In [1]: import numpy

    In [2]: numpy.newaxis is None
    Out[2]: True


The authors probably chose it because they needed a convenient constant, and `None` was available.

As for why you should prefer `newaxis` over `None`: mainly it&#39;s because it&#39;s more explicit, and partly because someday the `numpy` authors might change it to something other than `None`.  (They&#39;re not planning to, and probably won&#39;t, but there&#39;s no good reason to prefer `None`.)

What can you guys recommend to use with Java?

Only requirement is it should be open source, or has not too expensive academic licence .

Open Source Java Profilers

I have a python template engine that heavily uses regexp. It uses concatenation like:

    re.compile( regexp1 + &quot;|&quot; + regexp2 + &quot;*|&quot; + regexp3 + &quot;+&quot; )

I can modify the individual substrings (regexp1, regexp2 etc).

Is there any small and light expression that matches nothing, which I can use inside a template where I don&#39;t want any matches? Unfortunately, sometimes &#39;+&#39; or &#39;*&#39; is appended to the regexp atom so I can&#39;t use an empty string - that will raise a &quot;nothing to repeat&quot; error.

Regular expression syntax for &quot;match nothing&quot;?

In numpy one can use the &#39;newaxis&#39; object in the slicing syntax to create an axis of length one, e.g.:

    import numpy as np
    print np.zeros((3,5))[:,np.newaxis,:].shape
    # shape will be (3,1,5)

The [documentation states][1] that one can also use `None` instead of `newaxis`, the effect is exactly the same.

Is there any reason to choose one over the other? Is there any general preference or style guide? My impression is that `newaxis` is more popular, probably because it is more explicit. So is there any reason why `None` is allowed?


  [1]: http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#numpy.newaxis

Numpy: Should I use newaxis or None?

In numpy one can use the 'newaxis' object in the slicing syntax to create an axis of length one, e.g.:
<pre><code class="hljs language-python">import numpy as np
print np.zeros((3,5))[:,np.newaxis,:].shape
# shape will be (3,1,5)
</code></pre>
The <a href="http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#numpy.newaxis" target="_blank" rel="noopener noreferrer">documentation states</a> that one can also use <code>None</code> instead of <code>newaxis</code>, the effect is exactly the same.
Is there any reason to choose one over the other? Is there any general preference or style guide? My impression is that <code>newaxis</code> is more popular, probably because it is more explicit. So is there any reason why <code>None</code> is allowed?

Python&#39;s list type has an index() method that takes one parameter and returns the index of the first item in the list matching the parameter.  For instance:

    &gt;&gt;&gt; some_list = [&quot;apple&quot;, &quot;pear&quot;, &quot;banana&quot;, &quot;grape&quot;]
    &gt;&gt;&gt; some_list.index(&quot;pear&quot;)
    1
    &gt;&gt;&gt; some_list.index(&quot;grape&quot;)
    3

Is there a graceful (idiomatic) way to extend this to lists of complex objects, like tuples?  Ideally, I&#39;d like to be able to do something like this:

    &gt;&gt;&gt; tuple_list = [(&quot;pineapple&quot;, 5), (&quot;cherry&quot;, 7), (&quot;kumquat&quot;, 3), (&quot;plum&quot;, 11)]
    &gt;&gt;&gt; some_list.getIndexOfTuple(1, 7)
    1
    &gt;&gt;&gt; some_list.getIndexOfTuple(0, &quot;kumquat&quot;)
    2


getIndexOfTuple() is just a hypothetical method that accepts a sub-index and a value, and then returns the index of the list item with the given value at that sub-index.  I hope

Is there some way to achieve that general result, using list comprehensions or lambas or something &quot;in-line&quot; like that?  I think I could write my own class and method, but I don&#39;t want to reinvent the wheel if Python already has a way to do it.


Using Python&#39;s list index() method on a list of tuples or objects?

I&#39;ve got a pretty good working snippit of code, but I was wondering if anyone has any better suggestions on how to do this:

    val = &#39;&#39;.join([c for c in val if c in &#39;1234567890.&#39;])

What would you do?


Strip all non-numeric characters (except for &quot;.&quot;) from a string in Python

I find myself frequently using Python&#39;s interpreter to work with databases, files, etc -- basically a lot of manual formatting of semi-structured data.  I don&#39;t properly save and clean up the useful bits as often as I would like.  Is there a way to save my input into the shell (db connections, variable assignments, little for loops and bits of logic) -- some history of the interactive session?  If I use something like `script` I get too much stdout noise.  I don&#39;t really need to pickle all the objects -- though if there is a solution that does that, it would be OK.  Ideally I would just be left with a script that ran as the one I created interactively, and I could just delete the bits I didn&#39;t need.  Is there a package that does this, or a DIY approach?


How to save a Python interactive session?

What&#39;s the best way, both aesthetically and from a performance perspective, to split a list of items into multiple lists based on a conditional? The equivalent of:

    good = [x for x in mylist if x in goodvals]
    bad  = [x for x in mylist if x not in goodvals]

Is there a more elegant way to do this?

Here&#39;s the actual use case, to better explain what I&#39;m trying to do:

    # files looks like: [ (&#39;file1.jpg&#39;, 33L, &#39;.jpg&#39;), (&#39;file2.avi&#39;, 999L, &#39;.avi&#39;), ... ]
    IMAGE_TYPES = (&#39;.jpg&#39;,&#39;.jpeg&#39;,&#39;.gif&#39;,&#39;.bmp&#39;,&#39;.png&#39;)
    images = [f for f in files if f[2].lower() in IMAGE_TYPES]
    anims  = [f for f in files if f[2].lower() not in IMAGE_TYPES]


How to split a list based on a condition?

In python how do you dynamically add modules to a package while your program is running.

I want to be able to add modules to the package directory from an outside process, and be able to use those new modules in my program:

    import package
    
    def doSomething(name):
        pkg = __import__(&quot;package.&quot; + name)
        mod = getattr(pkg, name)
        mod.doSomething()

How do I do this?

Dynamic loading of python modules

What are the advantages of [NumPy][1] over regular Python lists?

I have approximately 100 financial markets series, and I am going to create a cube array of 100x100x100 = 1 million cells. I will be regressing (3-variable) each x with each y and z, to fill the array with standard errors.

I have heard that for &quot;large matrices&quot; I should use NumPy as opposed to Python lists, for performance and scalability reasons. Thing is, I know Python lists and they seem to work for me. 

What will the benefits be if I move to NumPy?

What if I had 1000 series (that is, 1 billion floating point cells in the cube)? 

  [1]: http://en.wikipedia.org/wiki/NumPy


What are the advantages of NumPy over regular Python lists?

[NumPy][1] is an extremely useful library, and from using it I&#39;ve found that it&#39;s capable of handling matrices which are quite large (10000 x 10000) easily, but begins to struggle with anything much larger (trying to create a matrix of 50000 x 50000 fails). Obviously, this is because of the massive memory requirements.

Is there is a way to create huge matrices natively in NumPy (say 1 million by 1 million) in some way (without having several terrabytes of RAM)?

  [1]: http://en.wikipedia.org/wiki/NumPy


Very large matrices using Python and NumPy

In a pylab program (which could probably be a matlab program as well) I have a numpy array of numbers representing distances: &lt;code&gt;d[t]&lt;/code&gt; is the _distance_ at time &lt;code&gt;t&lt;/code&gt; (and the timespan of my data is &lt;code&gt;len(d)&lt;/code&gt; time units).

The events I&#39;m interested in are when the distance is below a certain threshold, and I want to compute the duration of these events. It&#39;s easy to get an array of booleans with &lt;code&gt;b = d&amp;lt;threshold&lt;/code&gt;, and the problem comes down to computing the sequence of the lengths of the True-only words in &lt;code&gt;b&lt;/code&gt;. But I do not know how to do that efficiently (i.e. using numpy primitives), and I resorted to walk the array and to do manual change detection (i.e. initialize counter when value goes from False to True, increase counter as long as value is True, and output the counter to the sequence when value goes back to False). But this is tremendously slow.

&lt;b&gt;How to efficienly detect that sort of sequences in numpy arrays ?&lt;/b&gt;

Below is some python code that illustrates my problem : the fourth dot takes a very long time to appear (if not, increase the size of the array)


    from pylab import *
    
    threshold = 7
    
    print &#39;.&#39;
    d = 10*rand(10000000)
    
    print &#39;.&#39;
    
    b = d&lt;threshold
    
    print &#39;.&#39;
    
    durations=[]
    for i in xrange(len(b)):
        if b[i] and (i==0 or not b[i-1]):
            counter=1
        if  i&gt;0 and b[i-1] and b[i]:
            counter+=1
        if (b[i-1] and not b[i]) or i==len(b)-1:
            durations.append(counter)
    
    print &#39;.&#39;



find length of sequences of identical values in a numpy array (run length encoding)

I&#39;m trying to run over the parameters space of a 6 parameter function to study its numerical behavior before trying to do anything complex with it, so I&#39;m searching for an efficient way to do this.

My function takes float values given in a 6-dim numpy array as input. What I tried to do initially was this:

First, I created a function that takes 2 arrays and generate an array with all combinations of values from the two arrays:

    from numpy import *
    def comb(a,b):
        c = []
        for i in a:
            for j in b:
                c.append(r_[i,j])
        return c

Then, I used `reduce()` to apply that to m copies of the same array:

    def combs(a,m):
        return reduce(comb,[a]*m)

Finally, I evaluate my function like this:

    values = combs(np.arange(0,1,0.1),6)
    for val in values:
        print F(val)

This works but it&#39;s *way* too slow. I know the space of parameters is huge, but this shouldn&#39;t be so slow. I have only sampled 10&lt;sup&gt;6&lt;/sup&gt; (a million) points in this example and it took more than 15 seconds just to create the array `values`.

Do you know any more efficient way of doing this with numpy? 

I can modify the way the function `F` takes it&#39;s arguments if it&#39;s necessary.

Using numpy to build an array of all combinations of two arrays

I have two points in 3D:

    (xa, ya, za)
    (xb, yb, zb)

And I want to calculate the distance:

    dist = sqrt((xa-xb)^2 + (ya-yb)^2 + (za-zb)^2)

What&#39;s the best way to do this with NumPy, or with Python in general? I have:
    
    import numpy
    a = numpy.array((xa ,ya, za))
    b = numpy.array((xb, yb, zb))


Content Type	Original Author	Original Content on Stackoverflow
Question	nikow	View Question on Stackoverflow
Solution 1 - Python	AFoglia	View Answer on Stackoverflow

Numpy: Should I use newaxis or None?

Python Problem Overview

Python Solutions

Solution 1 - Python

Regular expression syntax for "match nothing"?

Open Source Java Profilers

Attributions