Endlich mal mein erste Python Prog..

Code-Stücke können hier veröffentlicht werden.
Benutzeravatar
Matflasch
User
Beiträge: 41
Registriert: Donnerstag 25. März 2004, 15:42
Wohnort: Hamburg
Kontaktdaten:

Endlich mal mein erste Python Prog..

Beitragvon Matflasch » Dienstag 19. April 2005, 15:54

Hi,

ich habe nun auch endlich mal mein erstes Python Programm geschrieben.
Ich Programmiere (auf der Arbeit) Java und finde Python eigentlich sehr gut, jedenfalls, was ich darüber gelesen habe.

Das Script habe ich innerhalb von ner Stunde mal schnell zusammengebastelt, ist nicht viel, aber recht nützlich ;)

Bisher nimmt das Programm 2 Zufallszahlen und bietet per Zufall die Addition oder Subtraktion an. Man muss halt das ergebnis eingeben und kann dann zur nächsten Aufgabe oder aufhören. (Habe sowas auch mal mit mehr funktionen in Ruby geschrieben, finde sowas für den Einstieg recht nett...).

Ihr könnt ja mal reinschauen und sagen, was ihr davon haltet.

(Gut ist der Code sicher noch nicht, aber das kommt noch *g*)

Mfg, Matflasch

Code: Alles auswählen

#!/usr/bin/env python

import random

class MTF_MathGame:
   def __init__(self):
      pass

   def rand(self):
      self.zahl1 = random.randrange(1,1000)
      self.zahl2 = random.randrange(1,1000)

   def start(self):
      self.nochmal = "j"
      while self.nochmal == "j":
         self.rand()
         self.art = random.randrange(1,3)
         if self.art == 1:
            self.add()
         elif self.art == 2:
            self.sub()
         self.nochmal = raw_input("Nochmal? (j/n) ")
         

   def add(self):
      self.rand()
      print "%d + %d = " % (self.zahl1, self.zahl2)
      self.ergebnis = raw_input("Ergebnis: ")
      self.ergebnis = int(self.ergebnis)
      if self.ergebnis == (self.zahl1 + self.zahl2):
         print "Richtig! %d + %d = %d" % (self.zahl1, self.zahl2, self.zahl1+self.zahl2)
      else:
         print "Flasch! %d + %d = %d" % (self.zahl1, self.zahl2, self.zahl1+self.zahl2)

   def sub(self):
      self.rand()
      print "%d - %d = " % (self.zahl1, self.zahl2)
      self.ergebnis = raw_input("Ergebnis: ")
      self.ergebnis = int(self.ergebnis)
      if self.ergebnis == (self.zahl1 - self.zahl2):
         print "Richtig! %d - %d = %d" % (self.zahl1, self.zahl2, self.zahl1-self.zahl2)
      else:
         print "Flasch! %d - %d = %d" % (self.zahl1, self.zahl2, self.zahl1-self.zahl2)



MathGame = MTF_MathGame()
MathGame.start()
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Dienstag 19. April 2005, 16:11

Hier mal schnell meine erweiterung:

Code: Alles auswählen

#!/usr/bin/env python

import random

class MTF_MathGame:
    def __init__(self, max=1000):
        self.max = max
   
    def rand(self):
        self.zahl1 = random.randrange(1,self.max)
        self.zahl2 = random.randrange(1,self.max)

    def start(self):
        self.nochmal = "j"
        while self.nochmal == "j":
            self.art = random.randrange(1,3)
            if self.art == 1:
                self.test( "+" )
            else:
                self.test( "-" )
            self.nochmal = raw_input("Nochmal? (j/n) ")

    def test( self, aktion ):
        self.rand()

        eingabe = int( raw_input("%d %s %d = " % (self.zahl1, aktion, self.zahl2)) )

        if aktion == "+" :
            ergebnis = self.zahl1 + self.zahl2
        else:
            ergebnis = self.zahl1 - self.zahl2

        if ergebnis == eingabe:
            print "Richtig!"
        else:
            print "Flasch!"
       
        print


if __name__ == "__main__":
    MathGame = MTF_MathGame( 100 )
    MathGame.start()

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
BlackJack

Beitragvon BlackJack » Dienstag 19. April 2005, 21:57

Dir ist schon klar, das man in Python im Gegensatz zu Java keine Klassen schreiben muss wenn es nicht nötig ist? Und warum verwendest Du ausschliesslich Instanzvariablen? Sogar bei welchen die eigentlich lokal sein könnten. Wenn man das nicht in eine Klasse verpacken würde, dann wären das alles globale Variablen die den Namensraum zumüllen. Stattdessen sollte man besser Parameter und Rückgabewerte benutzen um Werte in die Funktionen hinein, bzw. aus ihnen heraus zu bekommen.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5554
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Telfs (Tirol)
Kontaktdaten:

Beitragvon gerold » Mittwoch 20. April 2005, 00:57

BlackJack hat geschrieben:Dir ist schon klar, das man in Python im Gegensatz zu Java keine Klassen schreiben muss wenn es nicht nötig ist?

Hi BlackJack!

Jetzt übertreibst du schon ein wenig. Einer der Vorteile von Python ist, dass dich die Programmiesprache nicht in eine strikte objektorientierte Programmierung zwingt. Es sollte jedem selbst überlassen werden, welchen Programmierstiel er verwendet. Warum soll jemand, der aus der Java-Programmierung kommt und sich mit Klassen leicht tut und mit der OO-Programmierung "auf du und du ist", sofort aufhören Klassen zu verwenden, nur weil es nicht mehr notwendig ist?

Genauso verhält es sich auch mit Modulen. Wenn jemand gewohnt ist, jede Klasse in eine Datei zu schreiben, warum verdammtnochmal soll man ihm vorschreiben, dass er es jetzt nicht mehr tun darf?

Nichts für Ungut -- ich wollte das nur mal los werden. Beim Rest stimme ich dir ja zu :P

lg
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
Matflasch
User
Beiträge: 41
Registriert: Donnerstag 25. März 2004, 15:42
Wohnort: Hamburg
Kontaktdaten:

Beitragvon Matflasch » Mittwoch 20. April 2005, 11:24

Danke für die Beiträge!

Joah, mit der Zeit habe ich Klassen einfach für so praktisch empfunden, dass ich, es sei denn, es geht nicht anders, eigentlich nur noch klassen verwende.

Privat beschäftige ich mich noch viel mit PHP, und da sind Klassen auch sehr nützlich.
Ich hatte da ne ImageGallery angefangen und erst keine Klassen verwendet. Nach einiger Zeit wurde es so viel Quelltext, dass ich mich entschlossen hatte, das ganze in Klassen zu fassen. Das Wechseln zu den Klassen hat ein wenig gedauert, aber dann ging das Programmieren viel schneller, durch die Klassen ;)

Zu diesem Programm nun:
Ich könnte innerhalb der Klasse ja weniger Instanzvariablen benutzen, dann mehr mit Parametern und Rückgabewerten arbeiten, das stimmt.
Ich will das Programm auch noch erweitern, mit mehr mathematischen Funktionen, zumindest die 4 Grundrechenarten.

Ich werde mich, wenn ich Zeit finde, nachher noch daran setzen und das Ergebnis später dann posten...

Achja...
eine Frage zu den Instanzvariablen habe ich noch. Wenn ich nun innerhalb der Methode 'rand()' self.zahl1 schreibe, wird das automatisch eine instanzvariable, richtig?
Man muss diese nicht vorher angeben, sondern kann sie bilden, wann man will?

( Bei Java habe ich ja ne lange liste mit Variablen am anfang der Datei, etwas ungewohnt *g*)

Mfg, Matflasch
Benutzeravatar
Matflasch
User
Beiträge: 41
Registriert: Donnerstag 25. März 2004, 15:42
Wohnort: Hamburg
Kontaktdaten:

Beitragvon Matflasch » Mittwoch 20. April 2005, 15:40

Hier nun mal meine erweiterte Version:

Code: Alles auswählen

#!/usr/bin/env python

#import random
from random import randrange

class MTF_MathGame:
   def __init__(self, max=1000):
      self.max = max
      pass

   # Erstellt die Zufallszahlen
   def rand(self):
      self.zahl1 = randrange(1,self.max)
      self.zahl2 = randrange(1,self.max)
      self.art = randrange(1,4)
      
   # liest das Ergebnis ein
   def ergebnis(self):
      ergebnis = int(raw_input("Ergebnis: "))
      return ergebnis

   # Startet das Programm
   def start(self):
      nochmal = "j"
      while nochmal == "j":
         self.rand()
         if self.art == 1:
            self.add()
         elif self.art == 2:
            self.sub()
         elif self.art == 3:
            self.mult()
         else:
            self.div()
         nochmal = raw_input("Nochmal? (j/n) ")

   # Addition
   def add(self):
      print "%d + %d = " % (self.zahl1, self.zahl2)
      aufgabe = "%d + %d = %d" % (self.zahl1, self.zahl2, self.zahl1+self.zahl2)
      if self.ergebnis() == (self.zahl1 + self.zahl2):
         print "Richtig! %s" % aufgabe
      else:
         print "Flasch! %s" % aufgabe
   
   # Subtraktion
   def sub(self):
      print "%d - %d = " % (self.zahl1, self.zahl2)
      aufgabe = "%d - %d = %d" % (self.zahl1, self.zahl2, self.zahl1-self.zahl2)
      if self.ergebnis() == (self.zahl1 - self.zahl2):
         print "Richtig! %s" % aufgabe
      else:
         print "Flasch! %s" % aufgabe
   
   # Multiplikation
   def mult(self):
      print "%d * %d = " % (self.zahl1, self.zahl2)
      aufgabe = "%d * %d = %d" % (self.zahl1, self.zahl2, self.zahl1*self.zahl2)
      if self.ergebnis() == (self.zahl1 * self.zahl2):
         print "Richtig! %s" % aufgabe
      else:
         print "Flasch! %s" % aufgabe

   # Division
   def div(self):
      print "%d / %d = " % (self.zahl1, self.zahl2)
      aufgabe = "%d / %d = %d" % (self.zahl1, self.zahl2, self.zahl1/self.zahl2)
      if self.ergebnis() == (self.zahl1 / self.zahl2):
         print "Richtig! %s" % aufgabe
      else:
         print "Flasch! %s" % aufgabe

if __name__ == "__main__":
    MathGame = MTF_MathGame(10000)
    MathGame.start()


Viel Spass beim Kopfrechnen ;)

Ich mach mich dann mal an wxPython :D
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Mittwoch 20. April 2005, 17:06

pass kannst du dir in __init__() sparen!

Schau dir mal in meiner variante test() an...
add(), sub(), mult() und div() kannst du doch zusammen fassen... Sehr viele Teile darin sind gleich, bis auf die jeweilige Rechenart!

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5554
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Telfs (Tirol)
Kontaktdaten:

Beitragvon gerold » Mittwoch 20. April 2005, 17:12

Hi Matflasch!

Nur mal ein Hinweis für später: Wenn du die Kommentare, die du für die Funktionen angibst, nicht als Kommentar über dem Funktionskopf, sondern als String, direkt unterhalb des Funktionskopfs angibst, dann hast du eine Quellcode-Dokumentation, ohne einen Finger zu rühren.

Code: Alles auswählen

#-------------------------------------------------
def rand(self):
   "Erstellt die Zufallszahlen"
   self.zahl1 = randrange(1,self.max)
   self.zahl2 = randrange(1,self.max)
   self.art = randrange(1,4)


#-------------------------------------------------
def ergebnis(self):
   """
   Liest das Ergebnis ein
   """
   ergebnis = int(raw_input("Ergebnis: "))
   return ergebnis


Diese Docstrings werden z.B. in der Python-Shell angezeigt, wenn du help(funktionsname) eingibst. Mit pydoc (findest du im Lib-Ordner) wird daraus sogar eine komplette Dokumentation generiert.

mfg
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs

Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
BlackJack

Beitragvon BlackJack » Mittwoch 20. April 2005, 22:55

gerold hat geschrieben:
BlackJack hat geschrieben:Dir ist schon klar, das man in Python im Gegensatz zu Java keine Klassen schreiben muss wenn es nicht nötig ist?


Jetzt übertreibst du schon ein wenig. Einer der Vorteile von Python ist, dass dich die Programmiesprache nicht in eine strikte objektorientierte Programmierung zwingt. Es sollte jedem selbst überlassen werden, welchen Programmierstiel er verwendet. Warum soll jemand, der aus der Java-Programmierung kommt und sich mit Klassen leicht tut und mit der OO-Programmierung "auf du und du ist", sofort aufhören Klassen zu verwenden, nur weil es nicht mehr notwendig ist?


Ich bin vielleicht etwas unfreundlich rübergekommen. Aber Klassen sind, unabhängig davon welche Programmiersprache man verwendet, dazu da um eine Datenstruktur und dazugehörige Operationen zusammen zu fassen. Nur sehe ich hier die Datenstruktur nicht. Java zwingt einen trotzdem dazu eine Klasse drum herum zu basteln -- Python eben nicht.

Java erzwingt keine objektorientierte Programmierung, sondern nur das alles in einer Klasse sein muss. Das ist ein Unterschied. Wenn ich nur eine main-Methode habe und ein paar statische Methode die von dort aufgerufen werden, dann ist das nicht OOP weil sie in einer Klasse definiert sind, sondern stinknormale prozeduale Programmierung.

Ohne Klasse könnte es zum Beispiel so aussehen:

Code: Alles auswählen

#!/usr/bin/env python
import operator
import random

MAX_NUMBER = 1000

def integer_input(prompt):
    """Asks user for an integer value.
   
    Repeats until the user enters a valid integer value.
    """
    while True:
        try:
            return int(raw_input(prompt))
        except ValueError, error:
            print error


def bool_input(prompt):
    """Asks user for a boolean value.
   
    :returns: `True` if answer starts with 'y', 't', '1' or 'j' or is the
        empty string '', `False` otherwise.
    """
    answer = raw_input(prompt).lower()
    return answer[:1] in 'yt1j'


def main():
    """The main function."""
    #
    # Sequence of operations given as tuples of a symbol to display and a
    # binary function.
    #
    operations = (('+', operator.add), ('-', operator.sub))
   
    while True:
        number_a = random.randint(1, MAX_NUMBER)
        number_b = random.randint(1, MAX_NUMBER)
        symbol, operation = random.choice(operations)
       
        correct_result = operation(number_a, number_b)
        users_result = integer_input('%s %s %s = '
                                     % (number_a, symbol, number_b))
       
        if users_result == correct_result:
            print 'Correct result.'
        else:
            print 'Wrong result.  Correct answer is: %s' % correct_result
       
        if not bool_input('Continue? (y/n) '):
            break


if __name__ == '__main__':
    main()


Die beiden anderen Grundrechenarten nachzurüsten ist sehr einfach.
Benutzeravatar
Matflasch
User
Beiträge: 41
Registriert: Donnerstag 25. März 2004, 15:42
Wohnort: Hamburg
Kontaktdaten:

Beitragvon Matflasch » Donnerstag 21. April 2005, 07:04

@Jens,

ich hab es für besser gehalten, für jede Rechenart eine Methode zu haben, aber so langsam halte ich nichtmehr daran fest ;)

@Gerold
Ich habe gestern die Dokumentation mal mit den 'richtigen' Kommentaren generieren lassen. Erinnertmich irgendwie an JavaDoc ;)
Jedenfalls ist es ganz nett (bei mir bringt es ja noch nicht so viel, aber bei größeren Sachen ist das bestimmt sehr praktisch)

@BlackJack
Ja, öhm. Sehr kompakt kann ich grad nur sagen ;)
Ich bin es von Java her gewohnt, sehr Aufwendig zu programmieren (geht ja fast nicht anders). Ich hatte mich wohl eher an Java orientiert am Anfang und es ähnlich gemacht, wie ich es in Java gemacht hätte.

Ich kenne die Module von Python auch noch nicht (ist ja mein erstes Script). Aber ich glaube es schon einigermaßen zu verstehen und könnte es wohl erweitern auf die anderen Rechenarten.

Allerdings finde ich einige Sachen schon recht komplex. Die muss ich mir dann wohl noch 'etwas' genauer angucken.


Aber danke für die vielen Antworten!!!

Mfg, Matflasch
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5554
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Telfs (Tirol)
Kontaktdaten:

Beitragvon gerold » Donnerstag 21. April 2005, 09:03

BlackJack hat geschrieben: Aber Klassen sind, unabhängig davon welche Programmiersprache man verwendet, dazu da um eine Datenstruktur und dazugehörige Operationen zusammen zu fassen. Nur sehe ich hier die Datenstruktur nicht. Java zwingt einen trotzdem dazu eine Klasse drum herum zu basteln -- Python eben nicht.

Java erzwingt keine objektorientierte Programmierung, sondern nur das alles in einer Klasse sein muss. Das ist ein Unterschied. Wenn ich nur eine main-Methode habe und ein paar statische Methode die von dort aufgerufen werden, dann ist das nicht OOP weil sie in einer Klasse definiert sind, sondern stinknormale prozeduale Programmierung.


Hi BlackJack!

Ich habe fast zwei Stunden an meinem Kommentar gebastelt und versucht die richtigen Worte zu finden um aufzuzeigen, dass es verschiedene Programmierer gibt, die jeweils anders denken und ihre Programme in verschiedenen Stilen schreiben möchten.

Und dann stürzt mir der sch... Firefox ab :x :x :cry: :? :shock: :x

Deshalb gibt es jetzt nur mehr die kurze Zusammenfassung meiner Gedanken:

- Das ist kein Angriff auf BlackJack, sondern ein Aufzeigen meiner Gedanken zur Vielfältigkeit von Python und die Mischung von Denkweisen, die es beim Programmieren zulässt.

- OO-Programmierung beginnt im Kopf und muss von Anfang bis Ende durchgezogen werden. Macht man das nicht, dann ist es nicht OO-Programmierung sondern prozedurale Programmierung mit Objekten.

- In der OO-Programmierung können/sollten auch Programme als Objekt angesehen werden. Nur so kann man ungestört in der OO-Denkweise bleiben.

- OO-Programmierung bedeutet oft, um einiges mehr Code schreiben zu müssen, erleichtert aber die Sicht auf die Dinge, da der Programmierer eingeschränkter/spezifischer denken kann. Es gelten immer die gleichen Überlegungen: In welche Objekte kann ich mein Problem und dessen Umwelt aufteilen und welche Eigenschaften bzw. Methoden brauche ich um diese Umwelt virtuell abzubilden um damit mein Problem zu lösen.

- Das Mischen von prozeduraler Programmierung und OO-Programmierung erschwert das Programmieren für die, die von Anfang an (nur) die OO-Programmierung kennen und sich an die oben aufgezeigte Denkweise gewöhnt haben.

- Programmierer wie ich, die mit Prozeduraler-Programmierung aufgewachsen sind, werden ihre Programme wahrscheinlich bis an ihr Lebensende in einer Mischung aus prozeduraler und objektorientierter Programmierung schreiben.

- Die, die nur prozedural programmieren, werden auf längere Sicht aussterben, da andere Programmierer nicht mit ihnen zusammenarbeiten können.

- Python erlaubt verschiedene Denkweisen und gefällt mir deshalb so gut. Diskussionen wie "Soll man lambda oder print abschaffen?" führen, meiner Meinung nach, dazu dass sich Python immer mehr solchen Sprachen wie C# oder Java angleicht und einfache Sachen immer schwieriger werden. Ich glaube kaum, dass es viele Python-Programmierer gibt, die statt print "Hallo Welt" lieber system.console.writeline("Hallo Welt") schreiben.

Die häufig gebrauchten Sachen sollen einfach sein, der Rest zumindest möglich!

Leider ist dieser Kommentar nicht mehr so ausführlich und schön formuliert wie vor dem Absturz meines Firefox :shock: , aber einige Gedanken konnte ich noch reproduzieren.

lg
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs

Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
BlackJack

Beitragvon BlackJack » Donnerstag 21. April 2005, 22:07

gerold hat geschrieben:- Das ist kein Angriff auf BlackJack, sondern ein Aufzeigen meiner Gedanken zur Vielfältigkeit von Python und die Mischung von Denkweisen, die es beim Programmieren zulässt.


Hatte ich auch nicht als Angriff aufgefasst. Ich hoffe umgekehrt Du auch nicht.

- OO-Programmierung beginnt im Kopf und muss von Anfang bis Ende durchgezogen werden. Macht man das nicht, dann ist es nicht OO-Programmierung sondern prozedurale Programmierung mit Objekten.

- In der OO-Programmierung können/sollten auch Programme als Objekt angesehen werden. Nur so kann man ungestört in der OO-Denkweise bleiben.


Aber vieles ist einfach prozedualer Umgang mit Objekten. Das ist in vielen Fällen eine ganz natürliche herangehensweise.

Und man kann jedes Python-Programm als Objekt auffassen. Ich habe mich ja nicht daran gestossen, das Objekte benutzt wurden. Dann könnte man Python ja überhaupt nicht benutzen, weil im Gegensatz zu Java in Python eigentlich alles ein Objekt ist. Angefangen vom Integer über Funktionen und Klassen bis zu dem Programm selbst, was ja im Kontext eines Modul-Objekts abläuft. Und anstatt dieses Modul-Objekt mit seinem Namensraum zu benutzen, wurde unnötigerweise eine Klasse definiert, die nochmal einen eigenen Namensraum "aufmacht" aber im Modul ganz alleine dasteht.

- OO-Programmierung bedeutet oft, um einiges mehr Code schreiben zu müssen, erleichtert aber die Sicht auf die Dinge, da der Programmierer eingeschränkter/spezifischer denken kann. Es gelten immer die gleichen Überlegungen: In welche Objekte kann ich mein Problem und dessen Umwelt aufteilen und welche Eigenschaften bzw. Methoden brauche ich um diese Umwelt virtuell abzubilden um damit mein Problem zu lösen.


Das würde ich nicht unterschreiben. Ich muss nicht das Problem in Objekte aufteilen sondern nur zusammengehörige Daten und Funktionen darauf. Eben Quelltext, der mit Objekten hantiert. Der Code der das tut, darf aber ruhig prozedural sein. Das ist der Code in Methoden ja auch zwangsläufig.

Und wieder: In Python ist alles Objekt, also auch die angeblich prozeduale Funktion. Warum muss ich die dann in eine Klasse verpacken von der ich auch noch eine Instanz erzeugen muss um sie verwenden zu können. Der totale Overkill.

- Das Mischen von prozeduraler Programmierung und OO-Programmierung erschwert das Programmieren für die, die von Anfang an (nur) die OO-Programmierung kennen und sich an die oben aufgezeigte Denkweise gewöhnt haben.


Mit OO-Programmierung meinst Du jetzt aber speziell Java-OO bzw Sprachen die einen zwingen Klassen zu verwenden. Weil das in Python, Ruby, Objective-C und C++ zum Beispiel anders aussieht. Einige davon, wie Python und Ruby, sind in gewissen Sinne sogar viel "objektorientierter" weil dort alles Objekt ist.

- Programmierer wie ich, die mit Prozeduraler-Programmierung aufgewachsen sind, werden ihre Programme wahrscheinlich bis an ihr Lebensende in einer Mischung aus prozeduraler und objektorientierter Programmierung schreiben.


Meiner Meinung nach auch die richtige Lösung, weil auch im "richtigen Leben" nicht alles ein Objekt ist und vor allem nicht alles mit Zwang sinnvoll in eine Objekthierarchie gezwängt werden kann/sollte.

Vielleicht ändere ich diese Meinung auch mal irgendwann -- handgeschriebenen Assembler-Quelltext in Pascal-Programme einzustreuen habe ich ja mittlerweile auch aufgegeben. :wink:

- Python erlaubt verschiedene Denkweisen und gefällt mir deshalb so gut. Diskussionen wie "Soll man lambda oder print abschaffen?" führen, meiner Meinung nach, dazu dass sich Python immer mehr solchen Sprachen wie C# oder Java angleicht und einfache Sachen immer schwieriger werden. Ich glaube kaum, dass es viele Python-Programmierer gibt, die statt print "Hallo Welt" lieber system.console.writeline("Hallo Welt") schreiben.


Naja, gerade die beiden genannten Diskussionen finde ich gar nicht so schlimm. ``lambda`` verspricht einfach mehr als es kann, wenn man weiss was es in anderen Sprachen wie Lisp, Scheme oder Haskell leistet und es geht nicht um die Abschaffung von ``print`` sondern Guido bereut nur, dass er es als Schlüsselwort in die Sprache aufgenommen hat und nicht als einfache eingebaute Funktion. Mit ``print('Hallo Welt')`` als Alternative könnte ich jedenfalls leben.

Mich stört zum Beispiel die Diskussion um `map()`, `filter()` und `reduce()`. Und die Decorator-Syntax ist schon ein wenig "Perl-ish". :-)
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5554
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Telfs (Tirol)
Kontaktdaten:

Beitragvon gerold » Donnerstag 21. April 2005, 22:52

Hi BlackJack!

Ich kann dir nicht wirklich, groß widersprechen. So unterschiedlich sind unsere Meinungen ja nicht. Vielleicht hat noch jemand etwas dazu zu sagen. Ich glaube, es traut sich keiner mehr, sich bei diesem Thema einzumischen :wink:

Was soll´s. Ich drucke jetzt die Beschreibungen zu timedelta und Decorator-Syntax aus und lege mich ins Bett.

lg
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs

Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Freitag 22. April 2005, 08:20

Ich selber habe mir am Anfang immer wissen wollen, was OO ist... Leider sind die Beispiele dazu immer nach dem selben Muster gestrickt: Wir machen und ein Korb und dann packen wir was rein und danach machen wird uns einen zweite usw.
Man konnte es zwar irgendwie nachvollziehen, aber nicht praktisch Anwenden.
Jetzt denke ist, man muß nicht erstmal nicht darum kümmern! In erster Linie sollte man seine selbstgestellten Probleme lösen... Nach und nach blickt man immer weiter durch und der Rest geht von alleine...

Ich benutze mittlerweile Klassen auch recht gern, weil man so verschiedene Funktionen die Thematisch zusammenhängen, zusammenfassen kann. Das hat mit OO aber recht wenig zu tun...

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder