Solution 1

``````class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y

class Line(object):
def __init__(self, p1, p2):
self.p1 = p1
self.p2 = p2

def slope(self):
return (self.p2.y - self.p1.y) / (self.p2.x - self.p1.x)

def y_intercept(self):
m = self.slope()
return self.p1.y - (m * self.p1.x)

def formula(self):
tpl = 'y = {m}x + {b:g}'
m = self.slope()
if m == 1:
m = ''
return tpl.format(m=m, b=self.y_intercept())
``````

# Points and Lines

Time to make things a bit more complicated. Now you need to write two classes!

Create a class `Point` that receives two parameters `x` and `y` and stores them within each point created.

Next create a class `Line` that receives two points as parameters `p1` and `p2`.

It needs the following 3 methods:
`slope` that returns the slope of the line based on the two points
Equation: (y2 - y1)/(x2 - x1)
`y_intercept` that returns the y-intercept of the line
Equation: y1 - (slope * x1)
* `formula` that returns a string of the formula of the line (if the slope is 1, omit it).
Equation: y = mx + b where m is slope and b is y-intercept

Note: None of these methods receive any external parameters

For the `formula` string, if the y-intercept can be truncated (e.g. using 1 instead of 1.0), do it using {:g} in your string formatting.

``````"{b:g}".format(b=3.0) # 3
"{b:g}".format(b=3.2) # 3.2
``````

Example:

``````p1 = Point(0, 1)
p2 = Point(1, 2)

l = Line(p1, p2)

l.slope() # 1
l.y_intercept() # 1
l.formula() # 'y = x + 1.0'
``````

### Test Cases

test point -

``````def test_point():
p = Point(4, 2)
assert p.x == 4
assert p.y == 2``````

test line -

``````def test_line():
p1 = Point(0, 1)
p2 = Point(1, 2)

l = Line(p1, p2)

assert l.slope() == 1
assert l.y_intercept() == 1
assert l.formula() == 'y = x + 1'``````
# Define Point class here # Define Line class here