`floor()` rounds *down*. `int()` *truncates*. The difference is clear when you use negative numbers:

    &gt;&gt;&gt; import math
    &gt;&gt;&gt; math.floor(-3.5)
    -4
    &gt;&gt;&gt; int(-3.5)
    -3

Rounding down on negative numbers means that they move away from 0, truncating moves them closer to 0.

Putting it differently, the `floor()` is always going to be lower or equal to the original. `int()` is going to be closer to zero or equal.

I tested the time complexity of both methods, they are the same.
```python
from time import time
import math
import random

r = 10000000
def floorTimeFunction():
    for i in range(r):
	    math.floor(random.randint(-100,100))

def intTimeFunction():
    for i in range(r):
	    int(random.randint(-100,100))

t0 = time()
floorTimeFunction()
t1 = time()
intTimeFunction()
t2 = time()

print(&#39;function floor takes %f&#39; %(t1-t0))
print(&#39;function int     takes %f&#39; %(t2-t1))
```
Output is:

    # function floor takes 11.841985
    # function int   takes 11.841325

Both can be used to apply a function to a range of elements.

On a high level:

 - `std::for_each` ignores the return value of the function, and
   guarantees order of execution.
 - `std::transform` assigns the return value to the iterator, and does
   not guarantee the order of execution.

When do you prefer using the one versus the other? Are there any subtle caveats?

What is the difference between std::transform and std::for_each?

I&#39;m using Java 8 lambdas and want to use `Collectors` `toMap` to return a `SortedMap`. The best I can come up with is to call the following `Collectors` `toMap` method with a dummy `mergeFunction` and `mapSupplier` equal to `TreeMap::new`.

    public static &lt;T, K, U, M extends Map&lt;K, U&gt;&gt;
            Collector&lt;T, ?, M&gt; toMap(Function&lt;? super T, ? extends K&gt; keyMapper,
                    Function&lt;? super T, ? extends U&gt; valueMapper,
                    BinaryOperator&lt;U&gt; mergeFunction,
                    Supplier&lt;M&gt; mapSupplier) {
        BiConsumer&lt;M, T&gt; accumulator = (map, element) -&gt; map.merge(keyMapper.apply(element),
                valueMapper.apply(element), mergeFunction);
        return new CollectorImpl&lt;&gt;(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);
    }

I don&#39;t want to pass in a merge function though, as I just want `throwingMerger()`, in the same way as the basic `toMap`implementation as follows:

    public static &lt;T, K, U&gt;
            Collector&lt;T, ?, Map&lt;K, U&gt;&gt; toMap(Function&lt;? super T, ? extends K&gt; keyMapper,
                    Function&lt;? super T, ? extends U&gt; valueMapper) {
        return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);
    }

What would be the best practise method of using `Collectors` to return a `SortedMap`?

Java 8 Collectors.toMap SortedMap

In Python 2, `floor()` returned a float value. Although not obvious to me, I found a few explanations clarifying  why it may be useful to have `floor()` return float (for cases like `float(&#39;inf&#39;)` and `float(&#39;nan&#39;)`). 

However, in Python 3, `floor()` returns integer (and returns overflow error for the special cases mentioned before).

So what is the difference, if any, between `int()` and `floor()` now?

What is the difference between int() and floor() in Python 3?

In Python 2, <code>floor()</code> returned a float value. Although not obvious to me, I found a few explanations clarifying why it may be useful to have <code>floor()</code> return float (for cases like <code>float('inf')</code> and <code>float('nan')</code>).
However, in Python 3, <code>floor()</code> returns integer (and returns overflow error for the special cases mentioned before).
So what is the difference, if any, between <code>int()</code> and <code>floor()</code> now?

I can&#39;t get the average or mean of a column in pandas. A have a dataframe. Neither of things I tried below gives me the average of the column `weight`

    &gt;&gt;&gt; allDF 
             ID           birthyear  weight
    0        619040       1962       0.1231231
    1        600161       1963       0.981742
    2      25602033       1963       1.3123124     
    3        624870       1987       0.94212

    
The following returns several values, not one:

    allDF[[&#39;weight&#39;]].mean(axis=1)

So does this:

    allDF.groupby(&#39;weight&#39;).mean()

pandas get column average/mean

What is a clean way to create a multi-line `with` in python? I want to open up several files inside a single `with`, but it&#39;s far enough to the right that I want it on multiple lines. Like this:

    class Dummy:
        def __enter__(self): pass
        def __exit__(self, type, value, traceback): pass
    
    with Dummy() as a, Dummy() as b,
         Dummy() as c:
        pass

Unfortunately, that is a `SyntaxError`. So I tried this:

    with (Dummy() as a, Dummy() as b,
          Dummy() as c):
        pass

Also a syntax error. However, this worked:

    with Dummy() as a, Dummy() as b,\
         Dummy() as c:
        pass

But what if I wanted to place a comment? This does not work:

    with Dummy() as a, Dummy() as b,\
         # my comment explaining why I wanted Dummy() as c\
         Dummy() as c:
        pass

Nor does any obvious variation on the placement of the `\`s.

Is there a clean way to create a multi-line `with` statement that allows comments inside it?

Python multi-line with statement

I&#39;m using scikit-learn and numpy and I want to set the global seed so that my work is reproducible.

Should I use `numpy.random.seed` or `random.seed`?


From the link in the comments, I understand that they are different, and that the numpy version is not thread-safe. I want to know specifically which one to use to create IPython notebooks for data analysis. Some of the algorithms from scikit-learn involve generating random numbers, and I want to be sure that the notebook shows the same results on every run.

Should I use `random.seed` or `numpy.random.seed` to control random number generation in `scikit-learn`?

I&#39;d like to launch Chrome with its default profile using Python&#39;s webdriver so that cookies and site preferences persist across sessions.

How can I do that?

How to load default profile in Chrome using Python Selenium Webdriver?

I am a Python beginner and have a puzzle.
When I write code like this:
    
    lst = [1, 2, 3, 4]

Pycharm give me a prompt that is &quot;this list creation could be rewritten as a list literal&quot;.
But if it&#39;s replaced by
    
    lst = list([1, 2, 3, 4])

Pycharm doesn&#39;t say anything. Who could tell me why?

Is this code like `lst = [1, 2, 3, 4]` legal in Python? Can I ignore prompt?




When I assign a list to variable why Pycharm give me a prompt that is &quot;this list creation could be rewritten as a list literal&quot;?

I have read in an XML email attachment with

    bytes_string=part.get_payload(decode=False)

The payload comes in as a byte string, as my variable name suggests.

I am trying to use the recommended Python 3 approach to turn this string into a usable string that I can manipulate.

The example shows:

&gt;     str(b&#39;abc&#39;,&#39;utf-8&#39;)

How can I apply the `b` (bytes) keyword argument to my variable `bytes_string` and use the recommended approach?

The way I tried doesn&#39;t work:

    str(bbytes_string, &#39;utf-8&#39;)

How do I convert a Python 3 byte-string variable into a regular string?

While porting code from `python2` to `3`, I get this error when reading from a URL 

&gt;TypeError: initial_value must be str or None, not bytes.

    import urllib
    import json
    import gzip
    from urllib.parse import urlencode
    from urllib.request import Request

    
    service_url = &#39;https://babelfy.io/v1/disambiguate&#39;
    text = &#39;BabelNet is both a multilingual encyclopedic dictionary and a semantic network&#39;
    lang = &#39;EN&#39;
    Key  = &#39;KEY&#39;

        params = {
            &#39;text&#39; : text,
            &#39;key&#39;  : Key,
            &#39;lang&#39; :&#39;EN&#39;

            }
        
    url = service_url + &#39;?&#39; + urllib.urlencode(params)
    request = Request(url)
    request.add_header(&#39;Accept-encoding&#39;, &#39;gzip&#39;)
    response = urllib.request.urlopen(request)
    if response.info().get(&#39;Content-Encoding&#39;) == &#39;gzip&#39;:
                buf = StringIO(response.read())
                f = gzip.GzipFile(fileobj=buf)
                data = json.loads(f.read())

The exception is thrown at this line  

    buf = StringIO(response.read())  
If I use python2, it works fine.

Python3 error: initial_value must be str or None, with StringIO

I would like to extract a week number from data in a pandas dataframe.

The date format is datetime64[ns]

I have normalized the date to remove the time from it

    df[&#39;Date&#39;] = df[&#39;Date&#39;].apply(pd.datetools.normalize_date)

so the date now looks like - 2015-06-17 in the data frame column

and now I like to convert that to a week number.

Thanks in advance

converting a pandas date to week number

I have a list of namedtuples named `Books` and am trying to increase the `price` field by 20% which does change the value of `Books`. I tried to do:

    from collections import namedtuple
    Book = namedtuple(&#39;Book&#39;, &#39;author title genre year price instock&#39;)
    BSI = [
           Book(&#39;Suzane Collins&#39;,&#39;The Hunger Games&#39;, &#39;Fiction&#39;, 2008, 6.96, 20),
           Book(&#39;J.K. Rowling&#39;, &quot;Harry Potter and the Sorcerer&#39;s Stone&quot;, &#39;Fantasy&#39;, 1997, 4.78, 12)]
    for item in BSI:
        item = item.price*1.10
    print(item.price)

But I keep getting :

     Traceback (most recent call last):
     print(item.price)
     AttributeError: &#39;float&#39; object has no attribute &#39;price&#39;

 I understand that I cannot set the fields in a namedtuple. How do I go about updating `price`?


I tried to make it into a function:

    def restaurant_change_price(rest, newprice):
        rest.price = rest._replace(price = rest.price + newprice)
        return rest.price
    
    print(restaurant_change_price(Restaurant(&quot;Taillevent&quot;, &quot;French&quot;, &quot;343-3434&quot;, &quot;Escargots&quot;, 24.50), 25))

but I get an error with replace saying:

     rest.price = rest._replace(price = rest.price + newprice)
     AttributeError: can&#39;t set attribute

Can someone let me know why this is happening?

Changing values of a list of namedtuples

I&#39;m displaying a distance with one decimal, and I would like to remove this decimal in case it is equal to 0 (ex: 1200.0Km), how could I do that in swift?
I&#39;m displaying this number like this:

    let distanceFloat: Float = (currentUser.distance! as NSString).floatValue
    distanceLabel.text = String(format: &quot;%.1f&quot;, distanceFloat) + &quot;Km&quot;



Swift - How to remove a decimal from a float if the decimal is equal to 0?

It is well-known that NaNs propagate in arithmetic, but I couldn&#39;t find any demonstrations, so I wrote a small test:

    #include &lt;limits&gt;
    #include &lt;cstdio&gt;

    int main(int argc, char* argv[]) {
        float qNaN = std::numeric_limits&lt;float&gt;::quiet_NaN();

        float neg = -qNaN;

        float sub1 = 6.0f - qNaN;
        float sub2 = qNaN - 6.0f;
        float sub3 = qNaN - qNaN;

        float add1 = 6.0f + qNaN;
        float add2 = qNaN + qNaN;

        float div1 = 6.0f / qNaN;
        float div2 = qNaN / 6.0f;
        float div3 = qNaN / qNaN;

        float mul1 = 6.0f * qNaN;
        float mul2 = qNaN * qNaN;

        printf(
            &quot;neg: %f\nsub: %f %f %f\nadd: %f %f\ndiv: %f %f %f\nmul: %f %f\n&quot;,
            neg, sub1,sub2,sub3, add1,add2, div1,div2,div3, mul1,mul2
        );

        return 0;
    }

The example ([running live here](http://ideone.com/FjphJj)) produces basically what I would expect (the negative is a little weird, but it kind of makes sense):

    neg: -nan
    sub: nan nan nan
    add: nan nan
    div: nan nan nan
    mul: nan nan

MSVC 2015 produces something similar. However, Intel C++ 15 produces:

    neg: -nan(ind)
    sub: nan nan 0.000000
    add: nan nan
    div: nan nan nan
    mul: nan nan

Specifically, `qNaN - qNaN == 0.0`.

This... can&#39;t be right, right? What do the relevant standards (ISO C, ISO C++, IEEE 754) say about this, and why is there a difference in behavior between the compilers?


Why does NaN - NaN == 0.0 with the Intel C++ Compiler?

I&#39;m working through http://www.mypythonquiz.com, and [question #45](http://www.mypythonquiz.com/question.php?qid=255) asks for the output of the following code:

    confusion = {}
    confusion[1] = 1
    confusion[&#39;1&#39;] = 2
    confusion[1.0] = 4

    sum = 0
    for k in confusion:
        sum += confusion[k]
    
    print sum

The output is `6`, since the key `1.0` replaces `1`. This feels a bit dangerous to me, is this ever a useful language feature?

Why can a floating point dictionary key overwrite an integer key with the same value?

It is well known that in C, floating point literals (e.g. `1.23`) have type `double`. As a consequence, any calculation that involves them is promoted to double.

I&#39;m working on an embedded real-time system that has a floating point unit that supports only single precision (`float`) numbers. All my variables are `float`, and this precision is sufficient. I don&#39;t need (nor can afford) `double` at all. But every time something like

    if (x &lt; 2.5) ...

is written, disaster happens: the slowdown can be up to two orders of magnitude. Of course, the direct answer is to write

    if (x &lt; 2.5f) ...

but this is so easy to miss (and difficult to detect until too late), especially when a &#39;configuration&#39; value is `#define`&#39;d in a separate file by a less disciplined (or just new) developer.

So, is there a way to force the compiler to treat all (floating point) literals as float, as if with suffix `f`? Even if it&#39;s against the specs, I don&#39;t care. Or any other solutions? The compiler is gcc, by the way.

Make C floating point literals float (rather than double)

It looks like it could have been, there are (at least in C99) length modifiers that can be applied to `int`: `%hhd`, `%hd`, `%ld` and `%lld` mean `signed char`, `short`, `long` and `long long`. There is even a length modifier applicable to `double`: `%Lf` means `long double`.

The question is **why** did they omit `float`? Following the pattern, it might have been `%hf`.

Content Type	Original Author	Original Content on Stackoverflow
Question	datah4ck3r	View Question on Stackoverflow
Solution 1 - Python	Martijn Pieters	View Answer on Stackoverflow
Solution 2 - Python	amin saffar	View Answer on Stackoverflow

What is the difference between int() and floor() in Python 3?

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Java 8 Collectors.toMap SortedMap

What is the difference between std::transform and std::for_each?

Attributions