Das deutsche Python-Forum

Da sieht man mal, früher war alles besser. Heutzutage findet man nur noch ein- höchstens zweifarbige Äpfel...

Ganz früher stand in dem herausgebissenen Loch auch noch das "a" von "apple" drin. Mittlerweile ist das alles wegrationalisiert. Dem urhässlichen Windows-Logo würde das meiner Meinung nach allerdings gut tun

Das Windows-Logo ist wenigstens bunt. Und seit Vista auch nicht mehr ganz so hässlich ...

Außerdem: Einen Apfel kann jeder malen (noch dazu ohne Farbe), diese Windows-Fahne(?) ist da viel kreativer ... wahrscheinlich wissen nicht mal die MS-Leute selbst, was das eigentlich ist.

lunar hat geschrieben:Das Windows-Logo ist wenigstens bunt. Und seit Vista auch nicht mehr ganz so hässlich ...

Außerdem: Einen Apfel kann jeder malen (noch dazu ohne Farbe), diese Windows-Fahne(?) ist da viel kreativer ... wahrscheinlich wissen nicht mal die MS-Leute selbst, was das eigentlich ist.

Na ursprünglich war das eine Kreuzung aus fliegendem Fenster (muss wohl ein Kirchenfenster gewesen sein, wegen der vierfarbigen Scheiben) und Flagge, mit langer Bremsspur. In XP wurde der Rahmen wegrationalisiert sowie die Bremsspur entsorgt, In Vista haben sie es noch seltsam ausgeleuchtet. Zudem gibt es die Fassung wo das neue Vista-Logo in einer blauen Kugel ist, was das ganze irgendwie keinen deut hübscher macht und nur dazu führt dass die Leute die "Designed for Windows Vista"-Logos eher als früher von ihren Computern abkratzen.

lunar hat geschrieben:Das Windows-Logo ist wenigstens bunt. Und seit Vista auch nicht mehr ganz so hässlich ...

Na, dann ist das Logo wohl die Ausnahme (XPs Luna schweige ich bei diesem Vergleich nach allgemeinem Konsens mal tot

)

lunar hat geschrieben:Außerdem: Einen Apfel kann jeder malen (noch dazu ohne Farbe), diese Windows-Fahne(?) ist da viel kreativer ... wahrscheinlich wissen nicht mal die MS-Leute selbst, was das eigentlich ist.

Was ist an einem einfachen Logo schlecht? Das der Deutschen Bank oder das von Nike kann auch so ziemlich jeder nachpinseln. In meinen Augen macht genau diese Einfachheit und dieser Minimalismus ein gutes Logo und natürlich ein darauf aufgebautes Image aus.

Leonidas: Ein "Designed for Windows XP"-Icon in metallener Ausführung als Sticker klebt seit jeher auf meinem Mülleimer. Ich kann mir keinen passenderen Platz vorstellen.

YOGi, mein Posting war nicht ganz ernst gemeint ...

Muss mir entgangen sein

Y0Gi hat geschrieben:Leonidas: Ein "Designed for Windows XP"-Icon in metallener Ausführung als Sticker klebt seit jeher auf meinem Mülleimer. Ich kann mir keinen passenderen Platz vorstellen.

Das war definitiv der Lacher des Tages, habe es mal auf [wiki]Forum/Zitate[/wiki] verewigt.

Vielleicht verstehst du es ja so besser:

Code: Alles auswählen

# -*- coding: utf-8 -*-

class Vehicle(object):

    def __init__(self): # bekommt diese Eigenschaften wenn die Klasse aufgerufen wird
        self.wheels = 0
        self.oil = False
        self.fuel = False
        self.fueltype = None
        self.can_drive = False

    def get_fueltype(self):
        return self.fueltype
        
    def drive(self):
        if self.can_drive == True:
            return 'Wrumm'
        else:
            return 'Vehicle cannot drive'


class Car(Vehicle): # erbt Funktionen eines Fahrzeugs

    def __init__(self): # legt spezifische Eigenschaften eines PKW's fest
        Vehicle.__init__(self) # erbt im Fahrzeugkonstruktor festgelegte Eigenschaften
        self.fueltype = 'benzine' # Kraftstoffart wäre ein Beispiel von vielen

    def fill_up(self, type): # beschreibt die Tätigkeit des Auffüllens
        if type == 'benzine':
            self.fuel = True
        elif type == 'oil':
            self.oil = True
        else:
            return 'Not that type'
            
    def add_wheelpair(self):
        self.wheels += 2
            
    def set_drivability(self):
        if self.oil and self.fuel and self.wheels == 4:
            self.can_drive = True
            return 'Could drive now'
        else:
            return 'Not enough prepared for driving'

Code: Alles auswählen

In [1]: import drivable

In [2]: car = drivable.Car()

In [3]: car.drive()
Out[3]: 'Vehicle cannot drive'

In [4]: car.fill_up('oil')

In [5]: car.fill_up('kerosene')
Out[5]: 'Not that type'

In [6]: car.get_fueltype()
Out[6]: 'benzine'

In [7]: car.fill_up('benzine')

In [8]: car.set_drivability()
Out[8]: 'Not enough prepared for driving'

In [9]: car.add_wheelpair()

In [10]: car.wheels
Out[10]: 2

In [11]: car.add_wheelpair()

In [12]: car.can_drive
Out[12]: False

In [13]: car.set_drivability()
Out[13]: 'Could drive now'

In [14]: car.drive()
Out[14]: 'Wrumm'

Ich hoffe, du verstehst nun einigermaßen den Unterschied zwischen Eigenschaften, Funktionen und Klassen. Wie du siehst eignen sich Klassen hervorragend für funktionsübergreifende Zugriffe auf irgendwelche Werte und sie können ihre eigenen Attribute und Funktionen weitergeben. Zur Übung könntest du ja nun vielleicht mal die Klasse Airplane(Vehicle) schreiben...

EDIT: Da "type" ein reserviertes Wort ist, sollte man es bei fill_up() eigentlich nicht überschreiben. Aber du bist bestimmt kreativ genug, um dir eine passende Alternative auszudenken.

Oh endlich

Vielen dank

werde morgen oder am we nochmal meine klasse posten.

ich glaub dann sind wir hier fertig.
Nochmals danke x)

gruß , Rootmentor

Naja ich muss mal meckern snafu

Code: Alles auswählen

def get_fueltype(self):
        return self.fueltype

Man braucht keine simplen Getter(/Setter)

Code: Alles auswählen

def fill_up(self, type): # beschreibt die Tätigkeit des Auffüllens
        if type == 'benzine':
            self.fuel = True
        elif type == 'oil':
            self.oil = True

Du überschreibst `type' -> Böse

Mit dem "type" ist mir selber aufgefallen (siehe EDIT) und gut, das andere kann man sich sparen. Die Reifen hab ich mir ja auch anders angeguckt...

Code: Alles auswählen

#!/usr/bin/env python

class Fahrzeug(object):
    def __init__(self):
        self.fueltype = None
        self.candrive = False
        self.oil = None
        
    def fill_up(self):
        return self.fueltype
    
    def drive(self):
        if self.candrive == True:
            return "Dein Fahrzeug startet"
        else:
            return "Dein Fahrzeug kann nicht Fahren"
    
    def oil(self):
        return self.oil
    
    
class auto(Fahrzeug):
    def __init__(self):
        self.fueltype = "Benzin"
    
    def putoil(self):
        self.oil = "Standart Oel"
        
    def driving(self):
        if self.fueltype == "Benzin" and self.oil == "Standart Oel":a
            self.candrive = True

Auf das ihr mich zu gund und boden berichtigt!
Grüß , Rootmentor

Auf das ihr mich zu gund und boden berichtigt!

-> Auf, dass ihr mich zu Grund und Boden berichtigt!

Du wolltest es so *g*

Ich weiss jetzt ehrlich gesagt nicht, wie ich das bewerten soll. Es ist schliesslich kein echter Code sondern eher ein Gedankenspiel. So fehlen halt so Dinge wie das Volumen beim Öl oder Benzin/Diesel.

Aber so ein paar Sachen sag ich dann doch mal

Code: Alles auswählen

class Fahrzeug(object):
    def __init__(self):
        self.fueltype = None
        self.candrive = False
        self.oil = None

Würde ich in

Code: Alles auswählen

class Vehicle(object):
    def __init__(self, fueltype=None, oil=None, rideable=False):
        self.fueltype = fueltype
        self.oil = oil
        self.rideable = rideable

ändern. Einfach damit diese Werte gleich initialiisiert werden können.

Code: Alles auswählen

    def fill_up(self):
        return self.fueltype
   
    def drive(self):
        if self.candrive == True:
            return "Dein Fahrzeug startet"
        else:
            return "Dein Fahrzeug kann nicht Fahren"
   
    def oil(self):
        return self.oil

Sind nichts anderes als einfache Getter. Darauf kannst du verzichten.

Zum `auto' sag ich jetzt mal nichts mehr. Ausser: Hard coding is evil(tm).

Funktionale Programmierung ist dazu gedacht, externe Eingaben weiterzuverarbeiten. Das ist bei dir nicht möglich, da deine Funktionen keinerlei Parameter eingebaut haben.

Ich habe dir neben "fill_up()" explizit beschrieben, dass dies die Tätigkeit des Auffüllens beschreibt. Der Name der Funktion beschreibt also deren Sinn, wenn man so will (Stichwort: "sprechende Namen"). Bei dir tut sie etwas ganz anderes: Sie gibt die Kraftstoffart zurück. Folglich müsste sie "get_fueltype()" heißen. Zudem handelt es sich bei der Funktion um einen sogenannten Getter (da rächt es sich, dass ich mit schlechtem Beispiel voran gegangen bin). Das heißt: Du gibst ein Attribut zurück, dessen Wert man auch direkt über "self.fueltype" erhalten kann. Dieser zusätzliche Schritt ist schlichtweg unnötig.

Zum Auto: Während du den Kraftstofftyp korrekterweise in den Konstruktor setzt, baust die Art des Öls gesondert in "putoil()" ein. Abgesehen davon, dass es auch hier nicht um's Einfüllen des Öls, sondern vielmehr um "set_oiltype()" geht, könntest du ja hier zu Übung mal mit Parametern arbeiten:

Code: Alles auswählen

def set_oiltype(self, oiltype):
    if oiltype == 'motoroil':
        self.oil = True # dann muss self.oil aber vorher "False" statt "None" sein
    else:
        return "I won't drink that"

Zum Schluss würde ich auch wieder "driving()" entsprechend umbennen. Schliesslich geht es ja erst einmal um die Fahrtüchtigkeit des Autos. Das eigentliche Losfahren übernimmt die Funktion "drive()". Das if-Statement macht übrigens herzlich wenig Sinn, da bei deiner Klasse ohnehin kein anderer Wert als "Benzin" angenommen werden kann und in der jetzigen Form auch kein anderer Wert als "Standart Oel".

Ich hoffe du kannst durch die Kritik etwas für deine zukünftigen Klassen mitnehmen.

Sebastian

okay ich glaube mit einem pizza bestell programm könnte man ein gutes beispiel machen oder sehe ich das falsch?
Ich hab das mal bei youtube gesehn.
pizza.py -parameter -a - b -c -d
und dann is wirklich ne pizza nachher gekommen xD
warscheinlich gibts da nen pizza online bestell service.
Aber soweit wollt ich garnicht gehn.

ähh frage: Was soll das heißen "gleich initialisiert"?^^

Gruß , Rootmentor

Rootmentor hat geschrieben:Was soll das heißen "gleich initialisiert"?

Die Initialisierung findet in dem Moment statt wo du sagst:

Code: Alles auswählen

car = drivable.Car()

Dann wird "__init__" abgearbeitet (der Konstruktor). Cofi gibt den drei Variablen "fueltype", "oil", "rideable" dabei jeweils ein None mit, wodurch sowas möglich wird:

Code: Alles auswählen

vehicle = Vehicle(fueltype='benzine', oil='motor oil', rideable=True)

Das sind sogenannte Keyword-Argumente. Man legt dabei bestimmte Standardwerte fest, die eben gelten solange sie nicht verändert werden. Du könntest auch nur den fueltype umstellen, dann bleibt der Rest bei den Werten, wie sie in der Funktion angegeben wurden.

Deine Pizzaklasse könnte z.B. so initialisiert werden:

Code: Alles auswählen

class Pizza(object):
    def __init__(self, cheese='single'):
        self.cheese = cheese
    [...]
    def get_prize(self):
        if self.cheese == 'double':
            self.price += 0.5 # also 50cent Aufschlag bei doppelt Käse

achso alles klar

Ich glaub jetzt hab ichs verstanden xD

Code: Alles auswählen

class pizza(object):
    def __init_(self , grosse = "klein" , belag = "none"):
        self.grosse = "klein"
        self.belag = "belag"
        
        
    def order(self , grosse , belag):
        print "your pizza is " , grosse , "with " , belag
        
            
            

p = pizza()
p.order("klein" , "schinken")

Ich glaube nicht, dass Du's jetzt verstanden hast. `pizza.order()` ist völlig unabhängig von dem `pizza`-Exemplar, also keine richtige Methode, sondern eigentlich eine Funktion.

Das deutsche Python-Forum

Passwort abfrage

wow x)