Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python
from attrs import define, field


@define
class Cylinder:
    double = field()
    area = field()
    hole_area = field()
    _volume = field(default=None)

    @property
    def volume(self):
        """
        `calculate_volume`have to be called once before you can access this property.
        :raise ValueError: If `calculate_volume`is not be called before volume-access.
        :return float: volume in cubic-meter
        """
        if self._volume is None:
            raise ValueError(
                "Stroke-volume have to be calculated first. Call `calculate_stroke_volume`."
            )
        return self._volume

    def calculate_volume(self, length):
        """
        Depending on double acting the volume will be calculated.
        :param int|float length: In meter
        """
        area = self.area - self.hole_area if self.double else self.area
        self._volume = area * length


@define
class Machine:
    cylinders: list[Cylinder] = field()
    length = field()

    def __attrs_post_init__(self):
        for cylinder in self.cylinders:
            cylinder.calculate_volume(self.length)


def main():
    machine = Machine([Cylinder(100, 20, False)], 150)
    for cylinder in machine.cylinders:
        print(cylinder.volume)


if __name__ == "__main__":
    main()

Code: Alles auswählen

from attrs import define, field


@define
class Cylinder:
    area = field()
    hole_area = field()
    double = field()

    def calculate_volume(self, length):
        """
        Depending on double acting the volume will be calculated.
        :param int|float length: In meter
        """
        area = self.area - self.hole_area if self.double else self.area
        return area * length


@define
class Machine:
    cylinders = field()
    length = field()


def main():
    machine = Machine([Cylinder(100, 20, False)], 150)
    for cylinder in machine.cylinders:
        print(cylinder.calculate_volume(machine.length))


if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python
from attrs import define, field, make_class


Results = make_class(
    "Results",
    ["max_volume"],
)


@define
class Cylinder:
    double = field()
    area = field()
    hole_area = field()
    _volume = field(default=None)

    @property
    def volume(self):
        """
        `calculate_volume`have to be called once before you can access this property.
        :raise ValueError: If `calculate_volume`is not be called before volume-access.
        :return float: volume in cubic-meter
        """
        if self._volume is None:
            raise ValueError(
                "Stroke-volume have to be calculated first. Call `calculate_stroke_volume`."
            )
        return self._volume

    def calculate_volume(self, length):
        """
        Depending on double acting the volume will be calculated.
        :param int|float length: In meter
        """
        area = self.area - self.hole_area if self.double else self.area
        self._volume = area * length


@define
class Machine:
    cylinders: list[Cylinder] = field()
    length = field()
    speed = field()

    def __attrs_post_init__(self):
        for cylinder in self.cylinders:
            cylinder.calculate_volume(self.length)


def main():
    machine = Machine([Cylinder(100, 20, False), Cylinder(100, 20, True)], 150, 600)
    volume_flows = [machine.speed * cylinder.volume for cylinder in machine.cylinders]
    print(Results(max(volume_flows)))


if __name__ == "__main__":
    main()

Code: Alles auswählen

import math


class Cylinder:
    def __init__(self, diameter, height):
        self.diameter = diameter
        self.height = height

    @property
    def volume(self):
        return (self.diameter / 2)**2 * math.pi * self.height

    @classmethod
    def from_volume_diameter(cls, volume, diameter):
        g = (diameter / 2) ** 2 * math.pi
        h = volume / g
        return cls(diameter, h)
    
    @classmethod
    def from_volume_height(cls, volume, height):
        g = volume / height
        diameter = math.sqrt(g / math.pi) * 2
        return cls(diameter, height)        


z1 = Cylinder(5, 10)
print(f"{z1.diameter=} {z1.height=} {z1.volume=}")

z2 = Cylinder.from_volume_diameter(196.3495, 5)
print(f"{z2.diameter=} {z2.height=} {z2.volume=}")

z3 = Cylinder.from_volume_height(196.3495, 10)
print(f"{z3.diameter=} {z3.height=} {z3.volume=}")

Code: Alles auswählen

from typing import Self

class MachineCalculator:
    ...
    def add_cylinder(self, cylinder:Cylinder) -> Self:
        ...
    def add_XYZ(self, xyz:XYZ) -> Self:
        ...
...        
calculator = MaschineCalculator().add_cylinder(cylinder).add_XYZ(xyz)
result = calculator.calculate_something()

Code: Alles auswählen

class MachineCalculator:
    ...
    def __add__(self, component:Component) -> Self:
        match component:
            case Cylinder(height=height, diameter=diameter):
                ...
            case XYZ(x=x, y=y, z=z):
                ...
...
calculator = MaschineCalculator() + cylinder + xyz
result = calculator.calculate_something()

Code: Alles auswählen

from toolz.functoolz import flip

class Cylinder:
    ...
    def __mult__(self, n:int): tuple[Self]:
        return (self,) * n
        
    __rmult__ = flip(__mult__)
    ...
    
class MachineCalculator:
    ...
    def __add__(self, component:Component|tuple[Component]) -> Self:
        match component:
            case Component() as component, *components
                if not components:
                    return self + component
                return self + component + components
            ...
...
calculator = MaschineCalculator() + 2 * cylinder + xyz
result = calculator.calculate_something()