Python-Kurs

4 + 5

3.8 + 9

"Peter" + " " + "Pan"

[3,6,8] + [7,11,13]

from unit_conversions import Length
L = Length
print(L(2.56,"m") + L(3,"yd") + L(7.8,"in") + L(7.03,"cm"))

class Length: #Länge
    __metric = {"mm" : 0.001, "cm" : 0.01, "m" : 1, "km" : 1000,
                "in" : 0.0254, "ft" : 0.3048, "yd" : 0.9144,
                "mi" : 1609.344 }
    
    def __init__(self, value, unit = "m" ):
        self.value = value
        self.unit = unit
    
    def Convert2Metres(self): # in Meter umrechnen
        return self.value * Length.__metric[self.unit]
    
    def __add__(self, other):
        l = self.Convert2Metres() + other.Convert2Metres()
        return Length(l / Length.__metric[self.unit], self.unit )
    
    def __str__(self):
        return str(self.Convert2Metres())
    
    def __repr__(self):
        return "Length(" + str(self.value) + ", '" + self.unit + "')"
x = Length(4)
print(x)
y = eval(repr(x))
z = Length(4.5, "yd") + Length(1)
print(repr(z))
print(z)

x = Length(4)
print(x)
y = eval(repr(x))
z = Length(1, "ft") + Length(1)
print(repr(z))
print(z)

4.280839 * 0.3048

def __iadd__(self, other):
    l = self.Convert2Metres() + other.Convert2Metres()
    self.value = l / Length.__metric[self.unit]
    return self

x += Length(1)
x += Length(4, "yd")

def __add__(self, other):
    if type(other) == int or type(other) == float:
        l = self.Convert2Metres() + other
    else:
        l = self.Convert2Metres() + other.Convert2Metres()
    return Length(l / Length.__metric[self.unit], self.unit )
def __iadd__(self, other):
    if type(other) == int or type(other) == float:
        l = self.Convert2Metres() + other
    else:
        l = self.Convert2Metres() + other.Convert2Metres()
    self.value = l / Length.__metric[self.unit]
    return self

def __radd__(self, other):
    if type(other) == int or type(other) == float:
        l = self.Convert
        l = self.Convert2Metres() + other.Convert2Metres()
    return Length(l / Length.__metric[self.unit], self.unit )

def __radd__(self, other):
    return Length.__add__(self,other)  

def der_antwort(question):
    return 42
print("der_antwort: ", callable(der_antwort))

class Essen:
    
    def __call__(self):
        return "spam"
    
foo = Essen()
bar = Essen()
print(foo(), bar())

class DreieckFläche:
    
    def __call__(self, a, b, c):
        p = (a + b + c) / 2
        result = (p * (p - a) * (p - b) * (p - c)) ** 0.5
        return result
    
    
fläche = DreieckFläche()
print(fläche(3, 4, 5))

class GeradeLinien():
    
    def __init__(self, m, c):
        self.slope = m
        self.y_intercept = c
        
    def __call__(self, x):
        return self.slope * x + self.y_intercept
    
linie = GeradeLinien(0.4, 3)
for x in range(-5, 6):
    print(x, linie(x))

linien = []
linien.append(GeradeLinien(1, 0))
linien.append(GeradeLinien(0.5, 3))
linien.append(GeradeLinien(-1.4, 1.6))
import matplotlib.pyplot as plt
import numpy as np
X = np.linspace(-5,5,100)
for index, linie in enumerate(linien):
    line = np.vectorize(linie)
    plt.plot(X, line(X), label='Linie' + str(index))
plt.title('Gerade Linien')
plt.xlabel('x', color='#1C2833')
plt.ylabel('y', color='#1C2833')
plt.legend(loc='upper left')
plt.grid()
plt.show()

import random
class FuzzyDreieckFläche:
    
    def __init__(self, p=0.8, v=0.1):
        self.p, self.v = p, v
        
    def __call__(self, a, b, c):
        p = (a + b + c) / 2
        result = (p * (p - a) * (p - b) * (p - c)) ** 0.5
        if random.random() <= self.p:
            return result
        else:
            return random.uniform(result-self.v, 
                                  result+self.v)
        
fläche1 = FuzzyDreieckFläche()
fläche2 = FuzzyDreieckFläche(0.5, 0.2)
for i in range(12):
    print(f"{fläche1(3, 4, 5):4.3f}, {fläche2(3, 4, 5):4.2f}")

from random import uniform, random
from collections import Counter
class FuzzyDreieckFläche:
    def __init__(self, p=0.8, v=0.1):
        self.p, self.v = p, v
        
    def __call__(self, a, b, c):
        p = (a + b + c) / 2
        result = (p * (p - a) * (p - b) * (p - c)) ** 0.5
        if random() <= self.p:
            return result
        else:
            return uniform(result-self.v, 
                                  result+self.v)
     
   
class MergeExperts:
    
    def __init__(self, mode, *experts):
        self.mode, self.experts = mode, experts
        
    def __call__(self, a, b, c):
        results= [exp(a, b, c) for exp in self.experts]
        if self.mode == "Stimme":
            c = Counter(results)
            return c.most_common(1)[0][0]
        elif self.mode == "Mittelwert":
            return sum(results) / len(results)
rvalues = [(uniform(0.7, 0.9), uniform(0.05, 0.2)) for _ in range(20)]
experts = [FuzzyDreieckFläche(p, v) for p, v in rvalues]
merger1 = MergeExperts("Stimme", *experts)
print(merger1(3, 4, 5))
merger2 = MergeExperts("Mittelwert", *experts)
print(merger2(3, 4, 5))

class Polynomial:
    
    def __init__(self, *coefficients):
        self.coefficients = coefficients[::-1]
        
    def __call__(self, x):
        res = 0
        for index, coeff in enumerate(self.coefficients):
            res += coeff * x** index
        return res
# eine konstante Funktion
p1 = Polynomial(42)
# eine gerade Linie
p2 = Polynomial(0.75, 2)
# ein Polynom dritten Grades
p3 = Polynomial(1, -0.5, 0.75, 2)
for i in range(1, 10):
    print(i, p1(i), p2(i), p3(i))

class Plist(list):
    def __init__(self, l):
        list.__init__(self, l)
    def push(self, item):
        self.append(item)
if __name__ == "__main__":
    x = Plist([3,4])
    x.push(47)
    print(x)

%%writefile currencies.py
"""
Mit der Klasse "Ccy" können Geldwerte in verschiedenen Währungen definiert werden. Eine Ccy-Instanz hat die Zeichenfolgenattribute 'Einheit' (z. B. 'CHF', 'CAD' oder 'EUR' und den 'Wert' als Float.
     Ein Währungsobjekt besteht aus einem Wert und der entsprechenden Einheit.
    """
        
class Ccy:
    währungen =  {'CHF': 1.0821202355817312, 
                       'CAD': 1.488609845538393, 
                       'GBP': 0.8916546282920325, 
                       'JPY': 114.38826536281809, 
                       'EUR': 1.0, 
                       'USD': 1.11123458162018}
    
    def __init__(self, value, unit="EUR"):
        self.value = value
        self.unit = unit
    def __str__(self):
        return "{0:5.2f}".format(self.value) + " " + self.unit
    def changeTo(self, new_unit):
        """
            An Ccy object is transformed from the unit "self.unit" to "new_unit"
        """
        self.value = (self.value / Ccy.währungen[self.unit] * Ccy.währungen[new_unit])
        self.unit = new_unit
            
    def __add__(self, other):
        """
            Definiert den Operator '+'.
             Wenn other ein CCy-Objekt ist, werden die Währungswerte angegeben
             werden hinzugefügt und das Ergebnis ist die Einheit von
             selbst. Wenn other ein int oder ein float ist, wird other will
             als Euro-Wert behandelt werden.
        """
        if type(other) == int or type(other) == float:
            x = (other * Ccy.währungen[self.unit])
        else:
            x = (other.value / Ccy.währungen[other.unit] * Ccy.währungen[self.unit]) 
        return Ccy(x + self.value, self.unit)
    def __iadd__(self, other):
        """
            Ähnlich wie __add__
        """
        if type(other) == int or type(other) == float:
            x = (other * Ccy.währungen[self.unit])
        else:
            x = (other.value / Ccy.währungen[other.unit] * Ccy.währungen[self.unit])
        self.value += x
        return self
    def __radd__(self, other):
        res = self + other
        if self.unit != "EUR":
            res.changeTo("EUR")
        return res
        #__sub__, __isub__ und __rsub__ können analog definiert werden

from currencies import Ccy
x = Ccy(10,"USD")
y = Ccy(11)
z = Ccy(12.34, "JPY")
z = 7.8 + x + y + 255 + z
print(z)
lst = [Ccy(10,"USD"), Ccy(11), Ccy(12.34, "JPY"), Ccy(12.34, "CAD")]
z = sum(lst)
print(z)

%%writefile currency_converter.py
"""
Mit der Klasse "Ccy" können Geldwerte in verschiedenen Währungen definiert werden. Eine Ccy-Instanz hat die Zeichenfolgenattribute 'Einheit' (z. B. 'CHF', 'CAD' oder 'EUR' und den 'Wert' als Float.
     Ein Währungsobjekt besteht aus einem Wert und der entsprechenden Einheit.
"""   
class Ccy:
    währungen =  {'CHF': 1.0821202355817312, 
                       'CAD': 1.488609845538393, 
                       'GBP': 0.8916546282920325, 
                       'JPY': 114.38826536281809, 
                       'EUR': 1.0, 
                       'USD': 1.11123458162018}
        
    def __init__(self, value, unit="EUR"):
        self.value = value
        self.unit = unit
    def __str__(self):
        return "{0:5.2f}".format(self.value) + " " + self.unit
    def __repr__(self):
        return 'Ccy(' + str(self.value) + ', "' + self.unit + '")'
    def changeTo(self, new_unit):
        """
            Ein Ccy-Objekt wird von der Einheit "self.unit" in "new_unit" umgewandelt.
        """
        self.value = (self.value / Ccy.währungen[self.unit] * Ccy.währungen[new_unit])
        self.unit = new_unit
            
    def __add__(self, other):
        """
            Definiert den Operator '+'.
             Wenn other ein CCy-Objekt ist, werden die Währungswerte angegeben
             werden hinzugefügt und das Ergebnis ist die Einheit von
             selbst. Wenn other ein int oder ein float ist, wird other will
             als Euro-Wert behandelt werden.
        """
        if type(other) == int or type(other) == float:
                x = (other * Ccy.währungen[self.unit])
        else:
                x = (other.value / Ccy.währungen[other.unit] * Ccy.währungen[self.unit]) 
        return Ccy(x + self.value, self.unit)
    def __iadd__(self, other):
        """
            Ähnlich wie __add__
        """
        if type(other) == int or type(other) == float:
            x = (other * Ccy.währungen[self.unit])
        else:
            x = (other.value / Ccy.währungen[other.unit] * Ccy.währungen[self.unit])
            self.value += x
        return self
    def __radd__(self, other):
        res = self + other
        if self.unit != "EUR":
            res.changeTo("EUR")
        return res
        
        # __sub__, __isub__ und __rsub__ können analog definiert werden
        
    def __mul__(self, other):
        """
            Die Multiplikation wird nur als skalare Multiplikation definiert.
             d.h. ein Geldwert kann mit einem int oder einem float multipliziert werden.
             Es ist nicht möglich, sich mit Geldwerten zu multiplizieren
        """
        if type(other)==int or type(other)==float:
            return Ccy(self.value * other, self.unit)
        else:
            raise TypeError("unsupported operand type(s) for *: 'Ccy' and " + type(other).__name__)  
            
    def __rmul__(self, other):
        return self.__mul__(other)
        
    def __imul__(self, other):
        if type(other)==int or type(other)==float:
            self.value *= other
            return self
        else:
            raise TypeError("unsupported operand type(s) for *: 'Ccy' and " + type(other).__name__)      

from currency_converter import Ccy
x = Ccy(10.00, "EUR")
y = Ccy(10.00, "GBP")
x + y

print(x + y)

print(2*x + y*0.9)