Negative numbers mean that you count from the right instead of the left. So, `list[-1]` refers to the last element, `list[-2]` is the second-last, and so on.

List indexes of -x mean the xth item from the end of the list, so `n[-1]` means the last item in the list `n`. Any good Python tutorial should have told you this.

It&#39;s an unusual convention that only a few other languages besides Python have adopted, but it is extraordinarily useful; in any other language you&#39;ll spend a lot of time writing `n[n.length-1]` to access the last item of a list.



Every time I open up terminal on a Mac I get the prompt 

&gt; Would you like to check for updates?

I find it quite annoying. Anyway to stop it from doing so?


Oh My Zsh - Disable &#39;Would you like to check for updates&#39; prompt

I have been trying to work on creating a tree (like a directory tree) that uses as much CSS and as little JS as possible (only for states, etc), and I want to know if there are some good existing tree plugins for [bootstrap][1] or [jquery-ui bootstrap][2].

---

For reference or for people confused about this question, I am looking for something like [dynatree][3] for bootstrap.


  [1]: http://twitter.github.io/bootstrap/
  [2]: http://addyosmani.github.com/jquery-ui-bootstrap/
  [3]: https://github.com/mar10/dynatree

Trees in Twitter Bootstrap

I&#39;m trying to understand the following piece of code:

    # node list
    n = []
    for i in xrange(1, numnodes + 1):
        tmp = session.newobject();
        n.append(tmp)
    link(n[0], n[-1])

Specifically, I don&#39;t understand what the index `-1` refers to. If the index `0` refers to the first element, then what does `-1` refer to?

Negative list index?

I'm trying to understand the following piece of code:
<pre><code class="hljs language-ini"># node list
n = []
for i in xrange(1, numnodes + 1):
 tmp = session.newobject();
 n.append(tmp)
link(n[0], n[-1])
</code></pre>
Specifically, I don't understand what the index <code>-1</code> refers to. If the index <code>0</code> refers to the first element, then what does <code>-1</code> refer to?

I have experience in coding OpenMP for Shared Memory machines (in both C and FORTRAN) to carry out simple tasks like matrix addition, multiplication etc. (Just to see how it competes with LAPACK). I know OpenMP enough to carry out simple tasks without the need to look at documentation.

Recently, I shifted to Python for my projects and I don&#39;t have any experience with Python beyond the absolute basics.

My question is :

What is the *easiest* way to use OpenMP in Python? By easiest, I mean the one that takes least effort on the programmer side (even if it comes at the expense of added system time)?

The reason I use OpenMP is because a serial code can be converted to a working parallel code with a few `!$OMP`s scattered around. The time required to achieve a _rough_ parallelization is fascinatingly small. Is there any way to replicate this feature in Python?

From browsing around on SO, I can find:

- C extensions
- StackLess Python

Are there more? Which aligns best with my question?

OpenMP and Python

Is there a way in Python to do like this:

```py
a, b, = 1, 3, 4, 5
```

and then:

```py
&gt;&gt;&gt; a
1
&gt;&gt;&gt; b
3
```

The above code doesn&#39;t work as it will throw

&gt; `ValueError: too many values to unpack`


Unpack the first two elements in list/tuple

I am looking for a simple function that can generate an array of specified random values based on their corresponding (also specified) probabilities. I only need it to generate float values, but I don&#39;t see why it shouldn&#39;t be able to generate any scalar. I can think of many ways of building this from existing functions, but I think I probably just missed an obvious SciPy or NumPy function. 

E.g.:

    &gt;&gt;&gt; values = [1.1, 2.2, 3.3]
    &gt;&gt;&gt; probabilities = [0.2, 0.5, 0.3]
    &gt;&gt;&gt; print some_function(values, probabilities, size=10)
    (2.2, 1.1, 3.3, 3.3, 2.2, 2.2, 1.1, 2.2, 3.3, 2.2)

Note: I found **[scipy.stats.rv_discrete][1]** but I don&#39;t understand how it works. Specifically, I do not understand what this (below) means nor what it should do:

    numargs = generic.numargs
    [ &lt;shape(s)&gt; ] = [&#39;Replace with resonable value&#39;, ]*numargs

If rv_discrete is what I should be using, could you please provide me with a simple example and an explanation of the above &quot;shape&quot; statement?


  [1]: http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.rv_discrete.html#scipy.stats.rv_discrete

Generating Discrete random variables with specified weights using SciPy or NumPy

In Python, how would I pass an argument from the command line to a unittest function?

Here is the code so far… I know it&#39;s wrong.

    class TestingClass(unittest.TestCase):

        def testEmails(self):
            assertEqual(email_from_argument, &quot;my_email@example.com&quot;)


    if __name__ == &quot;__main__&quot;:
        unittest.main(argv=[sys.argv[1]])
        email_from_argument = sys.argv[1]


Python unittest passing arguments

A Pandas `DataFrame` contains column named `&quot;date&quot;` that contains non-unique `datetime` values. 
I can group the lines in this frame using:

    data.groupby(data[&#39;date&#39;])

However, this splits the data by the `datetime` values. I would like to group these data by the year stored in the &quot;date&quot; column. [This page][1] shows how to group by year in cases where the time stamp is used as an index, which is not true in my case.

How do I achieve this grouping?

  [1]: http://wesmckinney.com/blog/?p=125

How to group pandas DataFrame entries by date in a non-unique column

&gt; **Possible Duplicate:** &lt;br/&gt;
&gt; [Get difference from two lists in Python](https://stackoverflow.com/questions/5305164/get-difference-from-2-lists-python)

&lt;!-- End of automatically inserted text --&gt;

What is a simplified way of doing this? I have been trying on my own, and I can&#39;t figure it out. 
list a and list b, the new list should have items that are only in list a. So:

    a = apple, carrot, lemon
    b = pineapple, apple, tomato
    new_list = carrot, lemon

I tried writing code, but every time it always returns the whole list a to me. 



Remove list from list in Python

I am attempting to split a list into a series of smaller lists.

**My Problem:** My function to split lists doesn&#39;t split them into lists of the correct size. It should split them into lists of size 30 but instead it splits them into lists of size 114?

How can I make my function split a list into X number of Lists of size **30 or less**?

	public static List&lt;List&lt;float[]&gt;&gt; splitList(List &lt;float[]&gt; locations, int nSize=30) 
    {		
		List&lt;List&lt;float[]&gt;&gt; list = new List&lt;List&lt;float[]&gt;&gt;();
		
		for (int i=(int)(Math.Ceiling((decimal)(locations.Count/nSize))); i&gt;=0; i--) {
			List &lt;float[]&gt; subLocat = new List &lt;float[]&gt;(locations); 
			
			if (subLocat.Count &gt;= ((i*nSize)+nSize))
				subLocat.RemoveRange(i*nSize, nSize);
			else subLocat.RemoveRange(i*nSize, subLocat.Count-(i*nSize));
			
			Debug.Log (&quot;Index: &quot;+i.ToString()+&quot;, Size: &quot;+subLocat.Count.ToString());
			list.Add (subLocat);
		}
		
		return list;
	}

If I use the function on a list of size 144 then the output is:

&gt; Index: 4, Size: 120  
&gt; Index: 3, Size: 114  
&gt; Index: 2, Size: 114  
&gt; Index: 1, Size: 114  
&gt; Index: 0, Size: 114

Split a List into smaller lists of N size

It is very common for me to loop through a python list to get both the contents *and* their indexes. What I usually do is the following:

    S = [1,30,20,30,2] # My list
    for s, i in zip(S, range(len(S))):
        # Do stuff with the content s and the index i

I find this syntax a bit ugly, especially the part inside the `zip` function. Are there any more elegant/Pythonic ways of doing this?

Loop through list with both content and index

I&#39;m trying to make a list with numbers `1-1000` in it. Obviously this would be annoying to write/read, so I&#39;m attempting to make a list with a range in it. In Python 2 it seems that:

    some_list = range(1,1000)

would have worked, but in Python 3 the range is similar to the `xrange` of Python 2?

Can anyone provide some insight into this?

Python 3 turn range to a list

My attempt to programmatically create a dictionary of lists is failing to allow me to individually address dictionary keys. Whenever I create the dictionary of lists and try to append to one key, all of them are updated. Here&#39;s a very simple test case:

    data = {}
    data = data.fromkeys(range(2),[])
    data[1].append(&#39;hello&#39;)
    print data

Actual result: `{0: [&#39;hello&#39;], 1: [&#39;hello&#39;]}`

Expected result: `{0: [], 1: [&#39;hello&#39;]}`

Here&#39;s what works

    data = {0:[],1:[]}
    data[1].append(&#39;hello&#39;)
    print data

Actual and Expected Result: `{0: [], 1: [&#39;hello&#39;]}`

Why is the `fromkeys` method not working as expected?

Content Type	Original Author	Original Content on Stackoverflow
Question	Dawood	View Question on Stackoverflow
Solution 1 - Python	Toomai	View Answer on Stackoverflow
Solution 2 - Python	Russell Borogove	View Answer on Stackoverflow

Negative list index?

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Trees in Twitter Bootstrap

Oh My Zsh - Disable 'Would you like to check for updates' prompt

Attributions