La programmation orientée objet

from math import sqrt

class Cplx:
    def __init__(self, x, y):
        self.re = x
        self.im = y

    def __repr__(self):
        return str(self.re) + '+' + str(self.im) + 'i'

    def __add__(self, autre):
        return Cplx(self.re + autre.re, self.im + autre.im)

    def module(self):
        return sqrt(self.re**2 + self.im**2)

    def conjugue(self):
        return Cplx(self.re, -self.im)

    def inverse(self):
        m2 = self.module()**2
        return Cplx(self.re / m2, -self.im / m2)

    def __sub__(self, autre):
        return Cplx(self.re - autre.re, self.im - autre.im)

    def __mul__(self, autre):
        re = self.re * autre.re - self.im * autre.im
        im = self.re * autre.im + self.im * autre.re
        return Cplx(re, im)

    def __truediv__(self, autre):
        return self * autre.inverse()

    def __eq__(self, autre):
        return self.re == autre.re and self.im == autre.im

# Exemples
z1 = Cplx(1, 2)
z2 = Cplx(3, -4)
print(z1)            # 1+2i
print(z1 + z2)       # 4+-2i
print(z1 * z2)       # 11+2i
print(z1.module())   # 2.2360679...
print(z1 == z2)      # False
print(z1 / z2)       # appelle z1 * z2.inverse()

class Poly:
    def __init__(self, coeff, degre):
        self.c = coeff    # coefficients non nuls
        self.d = degre    # degrés associés (ordre décroissant)

    def __repr__(self):
        termes = [str(self.c[i]) + 'x^' + str(self.d[i])
                  for i in range(len(self.c))]
        return ' + '.join(termes)

    def __add__(self, autre):
        i, j = 0, 0
        Lc, Ld = [], []
        while i < len(self.d) and j < len(autre.d):
            if self.d[i] > autre.d[j]:
                Ld.append(self.d[i]); Lc.append(self.c[i]); i += 1
            elif self.d[i] < autre.d[j]:
                Ld.append(autre.d[j]); Lc.append(autre.c[j]); j += 1
            else:
                s = self.c[i] + autre.c[j]
                if s != 0:
                    Ld.append(self.d[i]); Lc.append(s)
                i += 1; j += 1
        while i < len(self.d):
            Ld.append(self.d[i]); Lc.append(self.c[i]); i += 1
        while j < len(autre.d):
            Ld.append(autre.d[j]); Lc.append(autre.c[j]); j += 1
        return Poly(Lc, Ld)

    def __sub__(self, autre):
        neg = Poly([-x for x in autre.c], autre.d[:])
        return self + neg

    def __eq__(self, autre):
        return self.c == autre.c and self.d == autre.d

    def eval(self, x):
        return sum(self.c[i] * x**self.d[i] for i in range(len(self.c)))

    def deriv(self):
        Lc = [self.c[i] * self.d[i] for i in range(len(self.c)) if self.d[i] != 0]
        Ld = [self.d[i] - 1 for i in range(len(self.d)) if self.d[i] != 0]
        return Poly(Lc, Ld)

    def integrale(self, a, b):
        prim_c = [self.c[i] / (self.d[i] + 1) for i in range(len(self.c))]
        prim_d = [self.d[i] + 1 for i in range(len(self.d))]
        P = Poly(prim_c, prim_d)
        return P.eval(b) - P.eval(a)

# Exemple
P = Poly([-5, 2, 1], [4, 3, 0])
print(P)          # -5x^4 + 2x^3 + 1
print(P.eval(1))  # -2
print(P.deriv())  # -20x^3 + 6x^2

class Rationnel:
    def __init__(self, n=0, d=1):
        self.numer = n
        self.denom = d
        self.irreductible()

    def pgcd(self, a, b):
        while b != 0:
            a, b = b, a % b
        return a

    def irreductible(self):
        if self.numer == 0:
            return
        p = self.pgcd(abs(self.numer), abs(self.denom))
        self.numer //= p
        self.denom //= p

    def setNumer(self, n):
        self.numer = n
        self.irreductible()

    def setDenom(self, d):
        self.denom = d
        self.irreductible()

    def __repr__(self):
        if self.numer == 0:
            return "0"
        if self.denom == 1:
            return str(self.numer)
        return str(self.numer) + "/" + str(self.denom)

    def __add__(self, autre):
        n = self.numer * autre.denom + self.denom * autre.numer
        return Rationnel(n, self.denom * autre.denom)

    def __mul__(self, autre):
        return Rationnel(self.numer * autre.numer, self.denom * autre.denom)

    def __truediv__(self, autre):
        return self * autre.inv()

    def __eq__(self, autre):
        return self.numer == autre.numer and self.denom == autre.denom

    def inv(self):
        return Rationnel(self.denom, self.numer)

# Utilisation
r1 = Rationnel(1, 2)
r2 = Rationnel(1, 3)
print(r1)          # 1/2
print(r1 + r2)     # 5/6
print(r1 * r2)     # 1/6
print(r1 / r2)     # 3/2

class PolynomeCreux:
    """Manipulation des polynômes creux à une seule variable."""

    def __init__(self):
        self.data = {}

    def ajout_monome(self, monome={}):
        if len(monome) == 0:
            # Q1 : saisie au clavier avec validations
            while True:
                n = int(input("degré = "))
                if n >= 0:
                    break
            while True:
                a = float(input("coefficient = "))
                if a != 0:
                    break
            self.data[n] = a
        else:
            n = list(monome.keys())[0]
            self.data[n] = list(monome.values())[0]

    def degree(self):
        # Q2
        return max(self.data.keys())

    def __call__(self, x0):
        # Q3
        return sum(self.data[c] * x0**c for c in self.data)

    def __add__(self, other):
        # Q4
        p = PolynomeCreux()
        all_deg = set(self.data.keys()) | set(other.data.keys())
        for d in all_deg:
            c = self.data.get(d, 0) + other.data.get(d, 0)
            if c != 0:
                p.ajout_monome({d: c})
        return p

    def __mul__(self, other):
        # Q5
        p = PolynomeCreux()
        for d1 in self.data:
            for d2 in other.data:
                d = d1 + d2
                c = self.data[d1] * other.data[d2]
                if d in p.data:
                    p.data[d] += c
                else:
                    p.data[d] = c
        p.data = {d: c for d, c in p.data.items() if c != 0}
        return p

    def __str__(self):
        # Q6
        if not self.data:
            return "0"
        L = sorted(self.data.keys(), reverse=True)
        termes = []
        for d in L:
            c = self.data[d]
            if d == 0:
                termes.append(str(c))
            elif d == 1:
                termes.append(str(c) + '*x')
            else:
                termes.append(str(c) + '*x**' + str(d))
        return ' + '.join(termes)

    def primitive(self):
        # Q7
        p = PolynomeCreux()
        for d in self.data:
            p.ajout_monome({d + 1: self.data[d] / (d + 1)})
        return p

    def integrale(self, a, b):
        # Q8
        return self.primitive()(b) - self.primitive()(a)

# Exemple
P = PolynomeCreux()
P.ajout_monome({2: 3})
P.ajout_monome({0: -1})
print(P)                  # 3*x**2 + -1
print(P(2))               # 11.0
print(P.integrale(0, 1))  # 2.0

from math import pi, sqrt

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

    def distance(self, point):
        return sqrt((self.x - point.x)**2 + (self.y - point.y)**2)

    def translate(self, dx, dy):
        self.x += dx
        self.y += dy

    def isobarycentre(self, points):
        tous = [self] + points
        mx = sum(p.x for p in tous) / len(tous)
        my = sum(p.y for p in tous) / len(tous)
        return Point(mx, my)

    def __repr__(self):
        return 'Point(' + str(self.x) + ', ' + str(self.y) + ')'

    def __eq__(self, autre):
        return self.x == autre.x and self.y == autre.y


class Segment:
    def __init__(self, point1, point2):
        self.point1 = point1
        self.point2 = point2

    def longueur(self):
        return self.point1.distance(self.point2)

    def milieu(self):
        mx = (self.point1.x + self.point2.x) / 2
        my = (self.point1.y + self.point2.y) / 2
        return Point(mx, my)

    def __repr__(self):
        return 'Segment(' + repr(self.point1) + ', ' + repr(self.point2) + ')'

    def __eq__(self, autre):
        return ((self.point1 == autre.point1 and self.point2 == autre.point2) or
                (self.point1 == autre.point2 and self.point2 == autre.point1))


class Cercle:
    def __init__(self, centre, rayon):
        self.centre = centre
        self.rayon = rayon

    def __repr__(self):
        return ('Cercle de centre (' + str(self.centre.x) + ',' +
                str(self.centre.y) + ') et de rayon ' + str(self.rayon))

    def getPerimetre(self):
        return 2 * pi * self.rayon

    def getSurface(self):
        return pi * self.rayon**2

    def appartient(self, point):
        return self.centre.distance(point) == self.rayon

    def interieur(self, point):
        return self.centre.distance(point) < self.rayon


class Rectangle:
    def __init__(self, coin_haut_gauche, coin_bas_droite):
        self.chg = coin_haut_gauche
        self.cbd = coin_bas_droite

    def getPerimetre(self):
        l = abs(self.cbd.x - self.chg.x)
        h = abs(self.cbd.y - self.chg.y)
        return 2 * (l + h)

    def getSurface(self):
        l = abs(self.cbd.x - self.chg.x)
        h = abs(self.cbd.y - self.chg.y)
        return l * h

# Exemples
A = Point(0, 0); B = Point(3, 4)
print(A.distance(B))            # 5.0
s = Segment(A, B)
print(s.longueur())             # 5.0
print(s.milieu())               # Point(1.5, 2.0)
c = Cercle(Point(0, 0), 5)
print(c)                        # Cercle de centre (0,0) et de rayon 5
r = Rectangle(Point(0, 4), Point(3, 0))
print(r.getPerimetre())         # 14
print(r.getSurface())           # 12

class VectorOfInt:

    def __init__(self, capacite=0):
        self.TE = [0] * capacite
        self.size = 0

    def ensureCapacity(self, c):
        if len(self.TE) < c:
            m = max(c, 2 * len(self.TE)) if len(self.TE) > 0 else c
            self.TE = self.TE + [0] * (m - len(self.TE))

    def __repr__(self):
        return ', '.join(str(self.TE[i]) for i in range(self.size))

    def resize(self, s):
        if len(self.TE) < s:
            self.ensureCapacity(s)
        self.size = s

    def getSize(self):
        return self.size

    def isEmpty(self):
        return self.size == 0

    def add(self, e):
        self.size += 1
        self.ensureCapacity(self.size)
        self.TE[self.size - 1] = e

    def set(self, i, e):
        if i < self.size:
            self.TE[i] = e

    def get(self, i):
        if i < self.size:
            return self.TE[i]
        return None

    def __getitem__(self, i):
        return self.get(i)

    def sum(self):
        return sum(self.TE[:self.size])

    def max(self):
        return max(self.TE[:self.size])

    def indexMax(self):
        return self.TE[:self.size].index(self.max())

    def sort(self):
        A = self.TE[:self.size]
        A.sort()
        self.TE[:self.size] = A

# Utilisation
v = VectorOfInt()
v.add(5); v.add(2); v.add(8); v.add(1)
print(v)             # 5, 2, 8, 1
print(v.max())       # 8
print(v.indexMax())  # 2
v.sort()
print(v)             # 1, 2, 5, 8

class StackOfInt:

    def __init__(self):
        self.v = VectorOfInt()

    def push(self, i):
        self.v.add(i)

    def peek(self):
        if self.v.getSize() == 0:
            return None
        return self.v[self.v.getSize() - 1]

    def pop(self):
        x = self.peek()
        if x is not None:
            self.v.resize(self.v.getSize() - 1)
        return x

    def size(self):
        return self.v.getSize()

    def isEmpty(self):
        return self.v.isEmpty()

# Utilisation
stack = StackOfInt()
stack.push(10)
stack.push(20)
stack.push(30)
print(stack.peek())  # 30
print(stack.pop())   # 30
print(stack.size())  # 2