Python类条件：从x输入获取[x，x]输出？

Question

I'm playing around with some interval calculations in Python. This is an excerpt of what I've written. I want to include degenerate intervals ie the interval for the real number 1 is [1,1].

So when I type Interval(1), I want [1,1] returned. But I've defined my interval class in terms of two parameters.

I can't make a subclass - it would still expect two parameters. Can anyone point me in the right direction please? Could I extend the __contains__ in some sense?

TLDR : How can I get an [x,x] output from an x input?

from numpy import *
import numpy as np
from pylab import *

class Interval:
    def __init__(self, LeftEndpoint, RightEndpoint):
        self.min = LeftEndpoint
        self.max = RightEndpoint
        if LeftEndpoint > RightEndpoint:
            raise ValueError('LeftEndpoint must not be greater than RightEndpoint') 

    def __repr__(self): #TASK 3
        return '[{},{}]'.format(self.min,self.max)

    def __contains__(self, num):
        if num < self.min:
            raise Exception('The number is not in the given interval')
        if num > self.max:
            raise Exception('The number is not in the given interval')

p = Interval(1,2)
print(p) #returns [1,2]

Answer 1

Just give RightEndpoint a default value, like None ; if it is still None in the function, you know no value was assigned to it and thus can be set to the same value as LeftEndpoint :

def __init__(self, LeftEndpoint, RightEndpoint=None):
    if RightEndpoint is None:
        RightEndpoint = LeftEndpoint

Note: if you follow the Python styleguide, PEP 8 , parameter and local variable names should be all lowercase_with_underscores. And the __contains__ method should really return True or False , not raise an exception:

class Interval:
    def __init__(self, left, right=None):
        if right is None:
            right = left
        if left > right:
            raise ValueError(
                'left must not be greater than right')
        self.left = left
        self.right = right

    def __repr__(self):
        return f'[{self.left}, {self.right}]'

    def __contains__(self, num):
        return self.left <= num <= self.right

Note that the __contains__ method can now be expressed as a single test; either num is in the (inclusive) range of left to right , or it is not.

Demo:

>>> Interval(1, 2)
[1, 2]
>>> Interval(1)
[1, 1]
>>> 11 in Interval(42, 81)
False
>>> 55 in Interval(42, 81)
True

Answer 2

You can use *args to pass in a variable number of arguments, then just assign RightEndpoint dynamically:

def __init__(self, *args):
        self.min = args[0]
        if len(args) < 2:
            RightEndpoint = args[0]
        elif len(args) == 2:
            RightEndpoint = args[1]
        else:
            # decide what to do with more than 2 inputs
        self.max = RightEndpoint
        #...


p = Interval(1,2)
print(p) #returns [1,2]
p1 = Interval(1) 
print(p1) #returns [1,1]

(Alternately you can use **kwargs if you want to use keyword arguments instead.)