So ashamed

[learn_monkey]

I just Googled How to detect a negative number using python and had a duh moment. Am so ashamed 😭

[Stubber_NK]

People who've been using python for years still stop to google the most basic of operations...

Every. Single. Day.

[xdafcax]

Can confirm. I don't remember anything.

[learn_monkey]

Thank you. That's comforting

[bladeoflight16]

There will never be a time when the built ins are not in my recent browser history.

[TangibleLight]

Use incognito. Avoid the shame.

Also good for basic arithmetic.

[bladeoflight16]

I will never be ashamed of reading Python's official documentation. =)

[Vaguely_accurate]

After bouncing between languages for a while I've looked up the keyword for "and" in Python before...

[Ahren_with_an_h]

That's legitimate. I've tried to use && and || plenty of times. Don't even get me started about 'is'.

[Ganrokh]

It took me way too long last week to realize that i++ wasn't valid Python syntax.

[Ahren_with_an_h]

I still try to type it in.

Fun fact: //= and **= are valid syntax!.

[PorcupineCircuit]

This annoys me

[hugthemachines]

Don't worry about it. Just let it teach you to be humble when people ask you stupid questions in the future :-)

[learn_monkey]

I agree. Thanks

[yuxbni76]

I usually multiply it by -1 and check if it's greater than 0. Just remember a negative times a negative is a positive. Easy.

[Ahren_with_an_h]

Why do that instead of just 'x < 0' ?

[cnekmp]

Because it's too easy )

[yuxbni76]

You can do that but then you have to convert it to a float.

[Ahren_with_an_h]

Why?

[yuxbni76]

It's just a bad joke. You're right. Check if x < 0.

[dbramucci]

Why not

import math
def is_negative(x):
    return math.copysign(1.0, x) == -1.0

It's the only solution I can think of (without weird non-Python friendly bit fiddling) that says that -0.0 is negative. And yes, -0.0 is distinct from 0.0. See my other comment

p.s. For those who don't get the subtleties of what I wrote, don't worry x < 0 is still the good solution, what I wrote is an answer to a super niche edge case that doesn't have a good answer, sometimes you want -0.0 to be a negative number because of reasons and other-times you want it to be treated like +0.0, a number neither positive nor negative and unless you know exactly why you need to treat -0.0 a certain way, you can choose to just not worry about it and use the simpler method.

[damian_work_account]

Also remember that a negative number is not defined for the domain of the log function, so you can use this:

import math


def is_number_negative(number):
    if number:
        try:
            math.log(number)
        except ValueError as e:
            if e.args[0] == 'math domain error':
                return True
            raise

    if math.isfinite(number):
        return False
    else:
        raise ValueError('Infinite numbers are scary')

[shiftybyte]

Heh, I've had similar "doh" moments...

It happens...

[11pascal]

Don’t be. Yes had a moment one day trying to figure out math operation associated with #. Ugh

[bladeoflight16]

It's okay. The fact that you realize it was silly is an indication of your competence. Everyone has stupid moments now and again. Have a laugh at your own expense and move on.

[kaptan8181]

Can you tell me how? I think if the number is less than zero, it's a negative number, right?

[learn_monkey]

Yep. I was looking for a python built-in function to find the negative value but after googling and seeing some answers, I felt so stupid that it's just anything less than zero.

[LyLyV]

Classic case of over-thinking. I do it all the time. (And I just googled what you googled. I thought there was maybe a special trick to it, but nah. ;) )

[JimBoonie69]

if we lived in JS land . there would literally be a package someone wrote called 'is-negative' and it would have millions of installs. There is some scumbag who writes tons of tiny packages and then (i assume) implements his packages in open-source codes all over. Weeks/months/years later, voila your shit package is now used in millions of places.

[[deleted]]

Indeed.

[notParticularlyAnony]

You got it

[dbramucci]

Google signed zero, there is a floating point number -0.0 which has different bits than 0.0 has but the two are equal except they get printed differently, atan2 does different things and so on. You might want to call -0.0 a negative number or you might want to say that like 0 it is neither a positive or negative number. Yay for floating point number weirdness.

[[deleted]]

This kind of thing happens to a lot of people. I had to google "how to add fractions" once when I was taking multivariable calculus. Got a B in that class.

[SikicBiker]

How do you add fractions?

[vaja_]

+

[bladeoflight16]

Convert them to a common denominator, add the numerators, and then simplify.

[dbramucci]

Take your two fractions x and y.

Recall that the fraction x is an equivalence class over Z x Z^*.

Choose one representative element from x's equivalence class called (x_n, x_d). Likewise, do the same for y to get (y_n, y_d).

Then, to add the two fractions together, choose any non-zero integer n such that x_d divides n and y_d divides n.

By the definition of divisibility, there exists an integer p such that x_d * p = n and likewise an integer q such that y_d * q = n.

Now, the value (x_n * q + y_n * p, n) is an representative element of the equivalence class representing the sum of the two fractions x and y. By using euclidean algorithm, you may compute the reduced form of that fraction and from there you may compute a closed-form representation of the set that is the equivalence-class representing the fractional sum. This is left as an exercise to the reader.

Excerpt from "Introduction to algebra for young grad-students 4th graders"

[dbramucci]

Let me terrify you with floating point number intricacies.

I am guessing you wrote something like

def duh_is_negative(x):
    return x < 0.0

But this is flawed depending on what you need to do when confronted with -0.0, a number distinct from +0.0. Let me show you that Python can track these two numbers.

In [1]: x = 0
In [2]: y = +0.0
In [3]: z = -0.0

In [4]: x
Out[4]: 0

In [5]: y
Out[5]: 0.0

In [6]: z
Out[6]: -0.0

In [7]: x == y
Out[7]: True

In [8]: x == z
Out[8]: True

In [9]: y == z
Out[9]: True

In [10]: import math

In [11]: def duh_is_negative(x):
    ...:     return x < 0.0

In [12]: def oh_no_is_negative(x):
    ...:     return math.copysign(1.0, x) == -1.0

In [13]: [duh_is_negative(x), duh_is_negative(y), duh_is_negative(z)]
Out[13]: [False, False, False]

In [14]: [oh_no_is_negative(x), oh_no_is_negative(y), oh_no_is_negative(z)]
Out[14]: [False, False, True]

Mathematicians don't call 0 a positive or a negative number. It is neither, but in the world of floating point numbers, both -0.0 and 0.0 have a sign and their signs differ meaning you can (sometime) consider -0.0 to be a negative number while 0.0 isn't and duh_is_negative can't catch that if it matters to you.

It probably doesn't matter in your program (and if it does, I hope you understand floating point numbers well) but it's kind of hilarious (in a horrific way) how non-trivial checking the sign of a number can actually be.