Swift 6, 58 54 53 39 bytes

{!($0+"").contains(/^(?!\.$)0*\.?0*$/)}

Alternatively (same byte count):

{($0+"").contains(/[^0.]|\..*\.|^\.$/)}

Try it on SwiftFiddle!

Perl 5 -p, 22 bytes

$_=!/^0*\.?0*$/|/^\.$/

Try it online!

grep -Ex, 13 bytes

Kinda trivial. Matches false line:

|0+\.?0*|\.0+

Attempt This Online!

Vyxal, 11 9 8 bytes

\0o\.¤"c

Try it Online!

Uses inverted booleans (1 for false and 0 for true).

-2 thanks to @pacman256

Explanation

\0o\.¤"c  # Implicit input
\0o       # Remove all 0s from the input
       c  # Is this new string in the following list:
   \.¤"   # [".", ""]?
          # Implicit output

Pyth, 10 bytes

-scSQ".0"0

Try it online! or Try the full test suite

Outputs an empty string (falsy in pyth) for falsy and a nonempty string (truthy in pyth) for truthy.

Explanation

              # Implicitly assign Q = eval(input())
   SQ         # sort input
  c  ".0"     # split on ".0" (this occurs a maximum of once in a sorted string)
 s            # concatenate list of strings back into a string
-        0    # remove all "0"s from string

JavaScript (Node.js), 15 bytes

s=>-s!=0+s+'e0'

Try it online!

• If s is number, then s==0 to make it false. e0 avoids another e in number(0e0).
• If s is ., x or o, then -s is NaN
• If s is 0 or 0 , then 0+s+0 is NaN

Assumes double handle enough logrange

Uiua, 18 bytes

<∩≍¬⊚.=@.⊃▽'△.≠@0.

Try it online!

Initially based on chunes' Factor answer, but it evolved a lot from it. Returns 1 if the input is falsy, 0 otherwise.

<∩≍¬⊚.=@.⊃▽'△.≠@0.    input: a string S
                  ≠@0.    keep S and push its non-zero-digit mask
          ⊃▽            S with zeros filtered out
       =@.                is-dot mask of above
 ∩≍¬⊚.                C1:is it the same as boolean negation of its nonzero indices?
(the length can be equal only if the mask is all ones, and the content equal only if
 the length is zero or one, i.e. the array is [] or [1].
 this tests if the input without zeros is either empty or a sole dot.
 now we need to filter out the case where S = ".")
 ∩≍       ⊃  '△.     C2:take the non-zero-digit mask, and test if it is the same
                          as its shape
(this test passes only if the array is [1])
<                         test if C1 is true and C2 is false

More explanation on the C1 condition:

The input is a boolean vector. ⊚ (where) on it collects the zero-based indices of ones, e.g. [1, 0, 1, 1, 0, 0, 1] becomes [0, 2, 3, 6]. The "logical negation" ¬ calculates 1-x for each value x in the array, e.g. [0, 2, 3, 6] becomes [1, -1, -2, -5].

For the input to equal its ¬⊚, the following conditions need to be met:

• The lengths are equal. For a boolean vector input, ⊚ generates a vector whose length is the count of ones in the input. To meet the length requirement, the input vector must be all ones.
• The individual values are equal. Since the input is boolean, the output must be also boolean (either 0 or 1). ¬ maps 2 or higher to negative numbers, so the original input cannot contain a 1 at indices 2 or higher. This reduces the candidates to [], [1], and [1,1].

Now we can do an exhaustive check:

input -> ⊚ -> ¬⊚
[] -> [] -> []
[1] -> [0] -> [1]
[1,1] -> [0,1] -> [1,0]

Therefore ≍¬⊚. checks if the given boolean vector is either [] or [1].

Uiua, 33 bytes 28 bytes (SBCS)

Edit: Using Bubbler's improved regex.

=0⧻regex"^0*(0\\.|\\.0)?0*$"

Try it online!

Not much to explain here - it just matches the regex with the input string and checks that the number of matches is 0.

Idiomatic Uiua, 39 bytes

(0;|(↥⊃'>⊢(<⊢⇌)∶1|1;)∊0∩/+⍉.∺="0.")>0⧻.

Try it online!

Explanation:

(0;|                                )>0⧻.   # If the length is 0 return 0. Otherwise:
                              ∺="0."        # Produce a matrix of matches with '0' and '.'
                           ⍉.              # Make a copy and transpose it
                        ∩/+                 # In both the original and transposed matrices, add up each row
    (             |1;)∊0                    # If there is a 0 in the per character array
                                            # (signifying a character other than '0' or '.'),
                                            # return 1. Otherwise:
                ∶1                          # Put a 1 on the stack and swap the top two items
      ⊃                                     # Apply both of the next functions to the same values
          (<⊢⇌)                            # Reverse the array and check if 1 < the first value
                                            # (This tests that the number of '.' chars is > 1)
       '>⊢                                  # Check if 1 > the first value
                                            # (This tests that the number of '0' chars is < 1)
     ↥                                      # Return the maximum of the two checks
# (This will return 0 if the number of '0' chars >= 1 AND the number of '.' <= 1)

Google Sheets, 37 34 bytes

=regexmatch(A1,"^0*\.?0*$")*(A1<>".")

Put the input in cell A1 and the formula in B1. Outputs 1 for falsey and 0 for truthy.

Using Bubbler's regex:

=regexmatch(A1,"^0*(0\.|\.0)?0*$")

Outputs TRUE for falsey and FALSE for truthy.

Acc!!, 107 bytes

Count i while 1-_/4 {
_*524+N
53308230694/5^(_/131+2*0^(_%131-48)^2+0^(_%131-46)^2+_^130%131)%5+1
}
Write _

Attempt This Online!

Takes the input NULL-terminated, returns chr(5) for truthy and chr(4) for falsey.

53308230694 encodes this table (minus 1, which is later added), which represents the transitions of a FSM for this language, and the rest of the code just converts the input to the correct format.

Where 0 is "null byte", 1 is "invalid character", 2 is ".", and 3 is "0". The state 4 is rejected, and 5 is accepted.

Pip, 16 13 bytes

aRM0N'.&!aQ'.

Try It Online!

-3 bytes thanks to @DLosc
Non-trivial pip answer, port of @Albert.Lang's answer

PowerShell Core, 31 bytes

"$args"-match"^0*(0\.|\.0)?0*$"

Try it online!

Down to 31 bytes using Bubbler's regex

Regex (any), 16 bytes

^0*(0\.|\.0)?0*$

Falsy matches the regex, truthy doesn't.

Python 3, 46 bytes

import re;re.compile(r"0*(0\.|\.0)?0*$").match

Try it online!

R, 36 bytes

\(s)trimws(s,,0)%in%c("",".")&s!="."

Attempt This Online!

Port of @Albert.Lang's answer.

Uses the whitespace argument of the trimws function introduced in R 3.6.0.

Python 3, 73 72 67 66 64 bytes

lambda v:not re.match("^(0+(\.0*)?|0*\.0+)$",v)and""<v
import re

Try it online!

Golfed reference implementation from @DLosc.

C (gcc), 75 bytes

i;f(char*s){return*s==48?i+=2,f(s+1):*s-46||i++&1?s=i!=1&!*s,i=0,s:f(s+1);}

Try it online!

05AB1E, 7 bytes

„+-₂‡{Ā

Try it online or verify all test cases.

Explanation:

    ‡    # Transliterate in the (implicit) input-string
„+-      # all "+" and "-"
   ₂     # to "2" and "6" respectively
     {   # Sort all characters in this string (based on codepoint)
      Ā  # 'Python-style' truthify this sorted string
         # (which is output implicitly as result)

The new 05AB1E is built in Elixir.
With just Ā, the 0. and 00. test cases are incorrectly truthy instead of falsey and the +0, -0, and 0e0 test cases are incorrectly falsey instead of truthy. The sort { is to fix 0., 00., and 0e0 and the transliterate „+-₂‡ to fix +0 and -0.

05AB1E (legacy), 8 bytes

…+- ₁‡{Ā

Try it online or verify all test cases.

Explanation:

     ‡    # Transliterate in the (implicit) input-string
„+-       # all "+", "-", and " "
    ₁     # to "2", "5", and "6" respectively
      {Ā  # Same as above
          # (after which the result is output implicitly)

The legacy version of 05AB1E is built in Python 3.
With just Ā, the 0, 0 , +0, -0, and 0e0 test cases are incorrectly falsey instead of truthy. The transliterate …+- ₁‡ is to fix 0, 0 , +0, and -0, and sort { is to fix 0e0 (thanks to @JonathanAllan for noticing a bug with this 0e0 test case).

2sable, 11 10 9 bytes

'.Q«Ô0Þså

Outputs an inverted boolean.

Try it online or verify all test cases.

Explanation:

'.Q       '# Check if the (implicit) input is equal to "."
   «       # Append this 1 or 0 to the (implicit) input
    Ô      # Connected uniquify (uniquifies groups of adjacent equal characters)
     0     # Push integer 0
      Þ    # Floatify and then stringify it: "0.0"
       så  # Check if the connected uniquify string is a substring of this
           # (so one of "", "0", "0.", ".0", "0.0", or "."†)
           # (which is output implicitly as result)

2sable is built in Python 3 as well, and is the oldest of the three versions and predecessor of the legacy 05AB1E version.
It lacks a lot of the builtins, including the Ā we use in the other two programs, so I had to find an alternative. I ended up using the connected uniquify builtin Ô and check whether the result is one of "", "0", "0.", .0", "0.0". I do this by checking whether it's a substring of "0.0".
† After which only the "." test case would incorrectly give a truthy instead of falsey result, which I've fixed by adding a leading '.Q«.

Factor + math.unicode, 45 bytes

[ dup "0"without "."subseq? swap "."≠ and ]

Attempt This Online!

Returns t for falsey and f for truthy. With zeros removed, is it a sub-sequence of "."? And is the original input not equal to "."?

Retina 0.8.2, 16 15 bytes

1`0\.|\.0

^0*$

Try it online! Link includes test cases. Explanation:

1`0\.|\.0

Delete at most one . adjacent to a 0.

^0*$

Match any number of zeros.

Charcoal, 9 bytes

∧№.⁻θ0⁻.θ

Try it online! Link is to verbose version of code. Outputs . for truthy, nothing for falsy. Note: Due to bugs in Charcoal's input, you need to input an empty string using a blank line. Explanation: Port of @Albert.Lang's Python answer.

 №          Count of
    θ       Input string
   ⁻ 0      With `0`s removed
  .         In literal string `.`
∧           Logical And
       .    Literal string `.`
      ⁻ θ   With input string removed

Python, 29 bytes

lambda s:s.strip("0")in"."!=s

Attempt This Online!

Outputs True for falsy and False for truthy.

Go, 106 bytes

import."regexp"
func f(s string)bool{return len(s)>0&&!MustCompile(`^(0+(\.0*)?|0*\.0+)$`).MatchString(s)}

Attempt This Online!

Port of the reference regexp.

JavaScript (Node.js), 23 bytes

s=>/[^0.]/.test(s)|s!=0

Try it online!

Trivial Pip answers, 1 byte

Thanks to decision-problem defaults, the identity function/program is a solution in Pip, since it turns falsey inputs into falsey outputs and truthy inputs into truthy outputs. Therefore, either of these full programs will work when given input as a command-line argument:

a
g

This program will work when given input on stdin:

q

And this works as a function solution:

_

While we're at it, logically negating the input gives some two- and three-byte solutions:

!a
!q
\!_

I'm making this post as a community wiki to head off these obvious answers (and other trivial solutions such as @g or {a} that are basically the same thing but longer). You are encouraged to post your own non-trivial Pip solutions.