I am trying to come up with a function that takes an input x and split a big list with the number of elements x*x into x smaller lists with x elements in every list E.g:   big_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]  def split_list (x): big_list = pairs (x) small_list = [big_list[0:x] for x in range (x)]   My output has to be:   [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]    but I'm not getting it, what do you recommend ?
740
I have a list of arbitrary length, and I need to split it up into equal size chunks and operate on it. There are some obvious ways to do this, like keeping a counter and two lists, and when the second list fills up, add it to the first list and empty the second list for the next round of data, but this is potentially extremely expensive.  I was wondering if anyone had a good solution to this for lists of any length, e.g. using generators.  I was looking for something useful in itertools but I couldn't find anything obviously useful. Might've missed it, though.  Related question:
1360
I want to create a list of lambda objects from a list of constants in Python; for instance:  listOfNumbers = [1,2,3,4,5] square = lambda x: x * x listOfLambdas = [lambda: square(i) for i in listOfNumbers]   This will create a list of lambda objects, however, when I run them:  for f in listOfLambdas:     print f(),   I would expect that it would print  1 4 9 16 25   Instead, it prints:  25 25 25 25 25   It seems as though the lambdas have all been given the wrong parameter. Have I done something wrong, and is there a way to fix it? I'm in Python 2.4 I think.  EDIT: a bit more of trying things and such came up with this:  listOfLambdas = [] for num in listOfNumbers:     action = lambda: square(num)     listOfLambdas.append(action)     print action()   Prints the expected squares from 1 to 25, but then using the earlier print statement:  for f in listOfLambdas:     print f(),   still gives me all 25s. How did the existing lambda objects change between those two print calls?  Related question:
42368
I have a python list, say l  l = [1,5,8]   I want to write a sql query to get the data for all the elements of the list, say  select name from students where id = |IN THE LIST l|   How do I accomplish this?
109876
In , the votes clearly show that the os.path.splitext function is preferred over the simple .split('.')[-1] string manipulation. Does anyone have a moment to explain exactly why that is? Is it faster, or more accurate, or what? I'm willing to accept that there's something better about it, but I can't immediately see what it might be. Might importing a whole module to do this be overkill, at least in simple cases?  EDIT: The OS specificity is a big win that's not immediately obvious; but even I should've seen the "what if there isn't a dot" case! And thanks to everybody for the general comments on library usage.
121693
To do the equivalent of Python list comprehensions, I'm doing the following:  some_array.select{|x| x % 2 == 0 }.collect{|x| x * 3}   Is there a better way to do this...perhaps with one method call?
103126
I dont know the concept or how to answer the question.     Suppose there are two sets, $X=\{1,2\}$ and $Y=\{a,b\}$.         What are all the ordered pairs in the form of (element of $X$, element of $Y$)?   What are all the ordered pairs in the form of (element of $Y$, element of $X$)?
9114
Suppose we have an iterator (an infinite one) that returns lists (or finite iterators), for example one returned by infinite = itertools.cycle([[1,2,3]])  What is a good Python idiom to get an iterator (obviously infinite) that will return each of the elements from the first iterator, then each from the second one, etc. In the example above it would return 1,2,3,1,2,3,.... The iterator is infinite, so itertools.chain(*infinite) will not work. Related
28240
I have the following data structure (a list of lists)  [  ['4', '21', '1', '14', '2008-10-24 15:42:58'],   ['3', '22', '4', '2somename', '2008-10-24 15:22:03'],   ['5', '21', '3', '19', '2008-10-24 15:45:45'],   ['6', '21', '1', '1somename', '2008-10-24 15:45:49'],   ['7', '22', '3', '2somename', '2008-10-24 15:45:51'] ]   I would like to be able to   Use a function to reorder the list so that I can group by each item in the list. For example I'd like to be able to group by the second column (so that all the 21's are together)  Use a function to only display certain values from each inner list. For example i'd like to reduce this list to only contain the 4th field value of '2somename'    so the list would look like this   [      ['3', '22', '4', '2somename', '2008-10-24 15:22:03'],       ['7', '22', '3', '2somename', '2008-10-24 15:45:51'] ]
96107
The code i used to write     is this one  $$ X(m,n)= \begin{cases} x(n),\\ x(n-1)\\ x(n-1) \end{cases} $$   But I don't know how to write this one     I appreciate any help.   Edited: I'm sorry to add this but what if I want to write this
116007
In , is the following the only way to get the number of elements?  arr.__len__()   If so, why the strange syntax?
10585
Right now I have vector3 values represented as lists. is there a way to subtract 2 of these like vector3 values, like  [2,2,2] - [1,1,1] = [1,1,1]   Should I use tuples?  If none of them defines these operands on these types, can I define it instead?  If not, should I create a new vector3 class?
5526
35 lines, 55 lines, 100 lines, 300 lines? When you should start to break it apart? I'm asking because I have a function with 60 lines (including comments) and was thinking about breaking it apart.  long_function(){ ... }   into:  small_function_1(){...} small_function_2(){...} small_function_3(){...}   The functions are not going to be used outside of the long_function, making smaller functions means more function calls, etc.  When would you break apart a function into smaller ones? Why?   Methods should do only one logical thing (think about functionality) You should be able to explain the method in a single sentence It should fit into the height of your display Avoid unnecessary overhead (comments that point out the obvious...) Unit testing is easier for small logical functions Check if part of the function can be reused by other classes or methods Avoid excessive inter-class coupling Avoid deeply nested control structures   Thanks everyone for the answers, edit the list and vote for the correct answer I'll choose that one ;)  I am refactoring now with those ideas in mind :)
87498
I've gotten stuck at the following exercise;     There are m functions from a one-element set to the set {1, 2, …, m}.   How many functions are there from a two-element set to {1, 2, …, m}?   From a three-element set? Give a recurrence for the number of T(n) of   functions from an n-element set to {1, 2, …, m}. Solve the recurrence.   I'm not sure how to begin solving it?
6059
How can I compute the number of lists of the form $(a_1,\ldots,a_k)$, where $a_i \geq 0$ are integers and $\sum a_i \leq n$? What is the easiest way to derive the answer?
16835
The Python list comprehension syntax makes it easy to filter values within a comprehension.  For example:  result = [x**2 for x in mylist if type(x) is int]   Will return a list of the squares of integers in mylist.  However, what if the test involves some (costly) computation and you want to filter on the result?  One option is:  result = [expensive(x) for x in mylist if expensive(x)]   This will result in a list of non-"false" expensive(x) values, however expensive() is called twice for each x.  Is there a comprehension syntax that allows you to do this test while only calling expensive once per x?
1888
I want to do something like String.Format("[{0}, {1}, {2}]", 1, 2, 3) which returns:  [1, 2, 3]   How do I do this in Python?
6976
What's the simplest, most standard, and/or most efficient way to split a List into two sub-Lists in Java? It's OK to mutate the original List, so no copying should be necessary. The method signature could be  /** Split a list into two sublists. The original list will be modified to  * have size i and will contain exactly the same elements at indices 0   * through i-1 as it had originally; the returned list will have size   * len-i (where len is the size of the original list before the call)   * and will have the same elements at indices 0 through len-(i+1) as   * the original list had at indices i through len-1.  */ &lt;T&gt; List&lt;T&gt; split(List&lt;T&gt; list, int i);   [EDIT] List.subList returns a view on the original list, which becomes invalid if the original is modified. So split can't use subList unless it also dispenses with the original reference (or, as in Marc Novakowski's answer, uses subList but immediately copies the result).