You can use an iterator:

    &gt;&gt;&gt; lis = (669256.02, 6117662.09, 669258.61, 6117664.39, 669258.05, 6117665.08)
    &gt;&gt;&gt; it = iter(lis)
    &gt;&gt;&gt; for x in it:
    ...     print (x, next(it))
    ...     
    669256.02 6117662.09
    669258.61 6117664.39
    669258.05 6117665.08



    &gt;&gt;&gt; nums = (669256.02, 6117662.09, 669258.61, 6117664.39, 669258.05, 6117665.08)
    &gt;&gt;&gt; for x, y in zip(*[iter(nums)]*2):
    	    print(x, y)
    
    	
    669256.02 6117662.09
    669258.61 6117664.39
    669258.05 6117665.08

The `grouper` example in the `itertools` recipes section should help you here:
http://docs.python.org/library/itertools.html#itertools-recipes

    from itertools import zip_longest
    def grouper(iterable, n, fillvalue=None):
        &quot;Collect data into fixed-length chunks or blocks&quot;
        # grouper(&#39;ABCDEFG&#39;, 3, &#39;x&#39;) --&gt; ABC DEF Gxx&quot;
        args = [iter(iterable)] * n
        return zip_longest(*args, fillvalue=fillvalue)

You would then it use like this:

    for x, y in grouper(my_set, 2, 0.0):  # Use 0.0 to pad with a float
        print(x, y)


    using (SqlConnection myDatabaseConnection = new SqlConnection(myConnectionString.ConnectionString))
    {
        myDatabaseConnection.Open();
        using (SqlCommand SqlCommand = new SqlCommand(&quot;Select Photo from Employee where EmpID LIKE &#39;%&#39; + @EmpID + &#39;%&#39; &quot;, myDatabaseConnection))
        {
            SqlCommand.Parameters.AddWithValue(&quot;@EmpID&quot;, textBox1.Text);
            var DS = new DataSet();
            var adapter = new SqlDataAdapter(SqlCommand);
            adapter.Fill(DS, &quot;Images&quot;);

            var imagesTable = DS.Tables[&quot;Images&quot;];
            var imagesRows = imagesTable.Rows;
            var count = imagesRows.Count;

            if (count &lt;= 0) return;
    
            var imageColumnValue =
                imagesRows[count - 1][&quot;Image&quot;];
            if (imageColumnValue == DBNull.Value)
                return;

            var data = (Byte[])imageColumnValue;
            using (var stream = new MemoryStream(data))
            {
                pictureBox1.Image = Image.FromStream(stream);
            }

        }
    }

If the image is too large for the `picturebox` to fit. What is the code to make the image fit in the `picturebox`?

My `picturebox` is squared, if the image is rectangular how to it crop and show it in the picturebox like [this][1], the lower part of the picture will be removed.


  [1]: https://fbcdn-sphotos-d-a.akamaihd.net/hphotos-ak-frc3/972271_592074960811667_1460987295_n.jpg &quot;this&quot;

Fit Image into PictureBox

What is the best way to implement global counters for a highly concurrent application?  In my case I may have 10K-20K go routines performing &quot;work&quot;, and I want to count the number and types of items that the routines are working on collectively...

The &quot;classic&quot; synchronous coding style would look like:


    var work_counter int

    func GoWorkerRoutine() {
        for {
            // do work
            atomic.AddInt32(&amp;work_counter,1)
        }    
    }

Now this gets more complicated because I want to track the &quot;type&quot; of work being done, so really I&#39;d need something like this:

    var work_counter map[string]int
    var work_mux sync.Mutex

    func GoWorkerRoutine() {
        for {
            // do work
            work_mux.Lock()
            work_counter[&quot;type1&quot;]++
            work_mux.Unlock()
        }    
    }

It seems like there should be a &quot;go&quot; optimized way using channels or something similar to this:

    var work_counter int
    var work_chan chan int // make() called somewhere else (buffered)

    // started somewher else
    func GoCounterRoutine() {
        for {
            select {
                case c := &lt;- work_chan:
                    work_counter += c
                    break
            }
        }
    }

    func GoWorkerRoutine() {
        for {
            // do work
            work_chan &lt;- 1
        }    
    }

This last example is still missing the map, but that&#39;s easy enough to add.  Will this style provide better performance than just a simple atomic increment?  I can&#39;t tell if this is more or less complicated when we&#39;re talking about concurrent access to a global value versus something that may block on I/O to complete...

Thoughts are appreciated.

Update 5/28/2013:

I tested a couple implementations, and the results were not what I expected, here&#39;s my counter source code:

    package helpers
    
    import (
    )
    
    type CounterIncrementStruct struct {
    	bucket string
    	value int
    }
    
    type CounterQueryStruct struct {
    	bucket string
    	channel chan int
    }
    
    var counter map[string]int
    var counterIncrementChan chan CounterIncrementStruct
    var counterQueryChan chan CounterQueryStruct
    var counterListChan chan chan map[string]int
    
    func CounterInitialize() {
    	counter = make(map[string]int)
    	counterIncrementChan = make(chan CounterIncrementStruct,0)
    	counterQueryChan = make(chan CounterQueryStruct,100)
    	counterListChan = make(chan chan map[string]int,100)
    	go goCounterWriter()
    }
    
    func goCounterWriter() {
    	for {
    		select {
    			case ci := &lt;- counterIncrementChan:
    				if len(ci.bucket)==0 { return }
    				counter[ci.bucket]+=ci.value
    				break
    			case cq := &lt;- counterQueryChan:
    				val,found:=counter[cq.bucket]
    				if found {
    					cq.channel &lt;- val
    				} else {
    					cq.channel &lt;- -1	
    				}
    				break
    			case cl := &lt;- counterListChan:
    				nm := make(map[string]int)
    				for k, v := range counter {
    				    nm[k] = v
    				}
    				cl &lt;- nm
    				break
    		}
    	}
    }
    
    func CounterIncrement(bucket string, counter int) {
    	if len(bucket)==0 || counter==0 { return }
    	counterIncrementChan &lt;- CounterIncrementStruct{bucket,counter}
    }
    
    func CounterQuery(bucket string) int {
    	if len(bucket)==0 { return -1 }
    	reply := make(chan int)
    	counterQueryChan &lt;- CounterQueryStruct{bucket,reply}
    	return &lt;- reply
    }
    
    func CounterList() map[string]int {
    	reply := make(chan map[string]int)
    	counterListChan &lt;- reply
    	return &lt;- reply
    }

It uses channels for both writes and reads which seems logical.

Here are my test cases:

    func bcRoutine(b *testing.B,e chan bool) {
    	for i := 0; i &lt; b.N; i++ {
    		CounterIncrement(&quot;abc123&quot;,5)
    		CounterIncrement(&quot;def456&quot;,5)
    		CounterIncrement(&quot;ghi789&quot;,5)
    		CounterIncrement(&quot;abc123&quot;,5)
    		CounterIncrement(&quot;def456&quot;,5)
    		CounterIncrement(&quot;ghi789&quot;,5)
    	}
    	e&lt;-true
    }
    
    func BenchmarkChannels(b *testing.B) {
    	b.StopTimer()
    	CounterInitialize()
    	e:=make(chan bool)
    	b.StartTimer()
    	
    	go bcRoutine(b,e)
    	go bcRoutine(b,e)
    	go bcRoutine(b,e)
    	go bcRoutine(b,e)
    	go bcRoutine(b,e)
    	
    	&lt;-e
    	&lt;-e
    	&lt;-e
    	&lt;-e
    	&lt;-e
    	
    }
    
    var mux sync.Mutex
    var m map[string]int
    func bmIncrement(bucket string, value int) {
    	mux.Lock()
    	m[bucket]+=value
    	mux.Unlock()
    }
    
    func bmRoutine(b *testing.B,e chan bool) {
    	for i := 0; i &lt; b.N; i++ {
    		bmIncrement(&quot;abc123&quot;,5)
    		bmIncrement(&quot;def456&quot;,5)
    		bmIncrement(&quot;ghi789&quot;,5)
    		bmIncrement(&quot;abc123&quot;,5)
    		bmIncrement(&quot;def456&quot;,5)
    		bmIncrement(&quot;ghi789&quot;,5)
    	}
    	e&lt;-true
    }
    
    func BenchmarkMutex(b *testing.B) {
    	b.StopTimer()
    	m=make(map[string]int)
    	e:=make(chan bool)
    	b.StartTimer()
    	
    	for i := 0; i &lt; b.N; i++ {
    		bmIncrement(&quot;abc123&quot;,5)
    		bmIncrement(&quot;def456&quot;,5)
    		bmIncrement(&quot;ghi789&quot;,5)
    		bmIncrement(&quot;abc123&quot;,5)
    		bmIncrement(&quot;def456&quot;,5)
    		bmIncrement(&quot;ghi789&quot;,5)
    	}
    	
    	go bmRoutine(b,e)
    	go bmRoutine(b,e)
    	go bmRoutine(b,e)
    	go bmRoutine(b,e)
    	go bmRoutine(b,e)
    	
    	&lt;-e
    	&lt;-e
    	&lt;-e
    	&lt;-e
    	&lt;-e
    	
    }

I implemented a simple benchmark with just a mutex around the map (just testing writes), and benchmarked both with 5 goroutines running in parallel.  Here are the results:

    $ go test --bench=. helpers
    PASS
    BenchmarkChannels         100000             15560 ns/op
    BenchmarkMutex   1000000              2669 ns/op
    ok      helpers 4.452s

I would not have expected the mutex to be that much faster...

Further thoughts?

Best way to implement global counters for highly concurrent applications?

I have a set like (669256.02, 6117662.09, 669258.61, 6117664.39, 669258.05, 6117665.08) which I need to iterate over, like

        for x,y in (669256.02, 6117662.09, 669258.61, 6117664.39, 669258.05, 6117665.08)
            print (x,y)

which would print

        669256.02 6117662.09
        669258.61 6117664.39
        669258.05 6117665.08

im on Python 3.3 btw

iterating over two values of a list at a time in python

I have a set like (669256.02, 6117662.09, 669258.61, 6117664.39, 669258.05, 6117665.08) which I need to iterate over, like
<pre><code class="hljs language-scss"> for x,y in (669256.02, 6117662.09, 669258.61, 6117664.39, 669258.05, 6117665.08)
 print (x,y)
</code></pre>
which would print
<pre><code class="hljs language-markdown"> 669256.02 6117662.09
 669258.61 6117664.39
 669258.05 6117665.08
</code></pre>
im on Python 3.3 btw

I have the following code for serializing the queryset;

    def render_to_response(self, context, **response_kwargs):

        return HttpResponse(json.simplejson.dumps(list(self.get_queryset())),
                            mimetype=&quot;application/json&quot;)

And following is my `get_querset()`

    [{&#39;product&#39;: &lt;Product: hederello ()&gt;, u&#39;_id&#39;: u&#39;9802&#39;, u&#39;_source&#39;: {u&#39;code&#39;: u&#39;23981&#39;, u&#39;facilities&#39;: [{u&#39;facility&#39;: {u&#39;name&#39;: {u&#39;fr&#39;: u&#39;G\xe9n\xe9ral&#39;, u&#39;en&#39;: u&#39;General&#39;}, u&#39;value&#39;: {u&#39;fr&#39;: [u&#39;bar&#39;, u&#39;r\xe9ception ouverte 24h/24&#39;, u&#39;chambres non-fumeurs&#39;, u&#39;chambres familiales&#39;,.........]}]


Which I need to serialize. But it says not able to serialize the `&lt;Product: hederello ()&gt;`. Because list composed of both django objects and dicts. Any ideas ? 

&lt;Django object &gt; is not JSON serializable

I have a model like this:

    class Hop(models.Model):
        migration = models.ForeignKey(&#39;Migration&#39;)
        host = models.ForeignKey(User, related_name=&#39;host_set&#39;)

How can I have the primary key be the combination of `migration` and `host`?







How can I set two primary key fields for my models in Django?

In python, I have a list that should have **one and only one** truthy value (that is, `bool(value) is True`). Is there a clever way to check for this? Right now, I am just iterating across the list and manually checking:

    def only1(l)
        true_found = False
        for v in l:
            if v and not true_found:
                true_found=True
            elif v and true_found:
                 return False #&quot;Too Many Trues&quot;
        return true_found

This seems inelegant and  not very pythonic. Is there a cleverer way to do this? 

 

How can I check that a list has one and only one truthy value?

I have a function that takes the argument `NBins`. I want to make a call to this function with a scalar `50` or an array `[0, 10, 20, 30]`. How can I identify within the function, what the length of `NBins` is? or said differently, if it is a scalar or a vector? 

I tried this:

    &gt;&gt;&gt; N=[2,3,5]
    &gt;&gt;&gt; P = 5
    &gt;&gt;&gt; len(N)
    3
    &gt;&gt;&gt; len(P)
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    TypeError: object of type &#39;int&#39; has no len()
    &gt;&gt;&gt; 

As you see, I can&#39;t apply `len` to `P`, since it&#39;s not an array.... Is there something like `isarray` or `isscalar` in python?

thanks

python: how to identify if a variable is an array or a scalar

Consider:

    &gt;&gt;&gt; lst = iter([1,2,3])
    &gt;&gt;&gt; next(lst)
    1
    &gt;&gt;&gt; next(lst)
    2

So, advancing the iterator is, as expected, handled by mutating that same object. 

This being the case, I would expect:

    a = iter(list(range(10)))
    for i in a:
       print(i)
       next(a)

to skip every second element: the call to `next` should advance the iterator once, then the implicit call made by the loop should advance it a second time - and the result of this second call would be assigned to `i`. 

It doesn&#39;t. The loop prints *all* of the items in the list, without skipping any. 

My first thought was that this might happen because the loop calls `iter` on what it is passed, and this might give an independent iterator - this isn&#39;t the case, as we have `iter(a) is a`. 

So, why does `next` not appear to advance the iterator in this case?

Python list iterator behavior and next(iterator)

In *Python 2.7*, I could get dictionary *keys*, *values*, or *items* as a list:

    &gt;&gt;&gt; newdict = {1:0, 2:0, 3:0}
    &gt;&gt;&gt; newdict.keys()
    [1, 2, 3]

Now, in *Python &gt;= 3.3*, I get something like this:

    &gt;&gt;&gt; newdict.keys()
    dict_keys([1, 2, 3])

So, I have to do this to get a list:

    newlist = list()
    for i in newdict.keys():
        newlist.append(i)

I&#39;m wondering, is there a better way to return a list in *Python 3*? 

How to return dictionary keys as a list in Python?

I looking for an **on-the-shelf** way to convert a List into a Map in Dart.

In python for example you can do:

    l= [ (&#39;a&#39;,(1,2)), (&#39;b&#39;,(2,3)), (&#39;c&#39;,(3,4) ) ]
    d=dict(l)
    ==&gt; {&#39;a&#39;: (1, 2), &#39;c&#39;: (3, 4), &#39;b&#39;: (2, 3)}

The dict function expects a List of couple. For each couple, the first element is used as the key and the second as the data.
 
In Dart I saw the following method for a List : **asMap()**, but it&#39;s not doing what i expect: it use the list index as key. 
My questions:

 - Do you known anything in Dart libraries to do this ?  
 - If not, any plan to add such a feature in the core lib ?

Proposal:

    List.toMap() //same as python dict.
    List.toMap( (value) =&gt; [ value[0], value[1] ] ) //Using anonymous function to return a key and a value from a list item.

Thanks and Regards,

Nicolas


How to convert a List into a Map in Dart

Is there is a way to measure how sorted a list is?

I mean, it&#39;s not about knowing if a list is sorted or not (boolean), but something like a ratio of &quot;sortness&quot;, something like the coefficient of correlation in statistics.

For example, 

 - If the items of a list are in ascending order, then its rate would be 1.0

 - If list is sorted descending, its rate would be -1.0

 - If list is almost sorted ascending, its rate would be 0.9 or some value close to 1.

 - If the list is not sorted at all (random), its rate would be close to 0

I&#39;m writting a small library in Scala for practice. I think a sorting rate would be useful, but I don&#39;t find any information about something like that. Maybe I don&#39;t know adequate terms for the concept.


Is there a way to measure how sorted a list is?

I&#39;m trying to develop a tool that read a binary file, makes some changes and save it. What I&#39;m trying to do is make a list of each line in the file, work with several lines and then join the list again.

This is what I tried:

    file = open(&#39;myFile.exe&#39;, &#39;r+b&#39;)

    aList = []
    for line in f:
        aList.append(line)

    #Here im going to mutate some lines.

    new_file = &#39;&#39;.join(aList)

and give me this error:

    TypeError: sequence item 0: expected str instance, bytes found

which makes sense because I&#39;m working with bytes.



Is there a way I can use join function o something similar to join bytes?
Thank you.


 

Content Type	Original Author	Original Content on Stackoverflow
Question	Rasmus Damgaard Nielsen	View Question on Stackoverflow
Solution 1 - Python	Ashwini Chaudhary	View Answer on Stackoverflow
Solution 2 - Python	jamylak	View Answer on Stackoverflow
Solution 3 - Python	Lllama	View Answer on Stackoverflow

iterating over two values of a list at a time in python

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Solution 3 - Python

Best way to implement global counters for highly concurrent applications?

Fit Image into PictureBox

Attributions