radians () error

[Roter Drache]

Hallöchen :)

ich habe mal eine Frage an euch..
und zwar wir sind nun in der Schule seid einiger Zeit von HTML zu Python gekommen. Soweit so schön funktionierte auch alles bis jetzt nun wollte ich aber eine Kreisdefinition machen bzw die aus der Schule noch ein bisschen anpassen und da bekomm ich immer eine Fehlermeldung. Da habe ich mal geguckt was es ist und der Eintrag radians() muckt hier auf.
:(

Was auch imemr das ist wenn ich nun (nicht mal in der Definition)

radians(0.5) oder radians(5) also egal was schreibe bekomm ich immer eine Fehlermeldung.
Die wie folgt aussieht:

TypeError: radians() takes no arguments (1 given)

was auch imemr das heißt???

die math.py lade ich mit

from math import * ein vlt. liegt da ja auch der Fehler ?? Wiegesagt bin auf dem Gebiet noch ein waschechter Newbi :)

Wenn ich irgend was vergessen habe sollte werde ich das selbst verständlich nachreichen hihi

Vielen Dank im vorraus :D

MfG Roter Drache

PS: Python 2.5.1 WinXP

[BlackVivi]

Hmpf, ich übersetz einfach mal die Fehlermeldung:

Radians benötigt keine Argumente (1 Argument gegeben)

Ich glaube, dass sollte selbsterklärend sein. Achja! Lass die bösen * importe. Importier lieber math und dann math.radians.

[gerold]

die math.py lade ich mit
from math import *

Hallo Roter Drache!

Willkommen im Python-Forum!

Was heißt hier die ``math.py``? Hast du eine Datei die so heißt? Wenn JA, dann überschreibst du damit das mit Python mitgelieferte Modul. Und sag' deinem Lehrer, dass Stern-Importe oft Fehler verursachen und deshalb gar nicht erst unterrichtet werden sollten. Nur erklären, aber nicht praktizieren.

Und wenn du eine Fehlermeldung bekommst (Traceback), dann zeige uns bitte immer die ganze Meldung. Dort steht oft etwas drinnen, das auf den Fehler schließen lässt.

Auch ein bischen Code bringt uns meist der Lösung näher.

mfg
Gerold

[Roter Drache]

Hallo,

Danke :), das mit dem * import wusste ich nicht der LEErersagt Schüler machen bis man sich selbst schlau macht ... 8)

math.py ging jetzt davon aus das die Bibliothek von Python so heißt, mit dem davon ausgehen ist immer so eine Sache *dumdidum*.

Habs halt so gelernt, hoffe mir sei verziehn.
Das radians keine Argumente benötigt ist für mich irgend wie sinnfrei deswegen habe ich ja Rat bei euch gesucht :roll: ...
der Code sieht wie folgt aus :

Code: Alles auswählen

def Ellipse(XPosition,YPosition,XRadius,YRadius,Startwinkel,Endwinkel,Schritte):
    penup()
    dx=XRadius*cos(radians(Startwinkel))
    dy=YRadius*sin(radians(Startwinkel))
    goto(x+dx,y+dy)
    pendown()
    Winkel=(Endwinkel-Startwinkel)/Schritte
    for i in range(Schritte):
        dx=XRadius*cos(radians(i+1)*Winkel)
        dy=YRadius*sin(radians(i+1)*Winkel)
        goto(x+dx,y+dy)
    penup()
    goto(x,y)
    pendown()

so und dort bekomme ich immer die Fehlermeldung

Traceback (most recent call last):
File "C:\...\sda.py", line 48, in <module>
Ellipse(0,0,10,10,0,360,360)
File "C:\...\sda.py", line 14, in Ellipse
dx=XRadius*cos(radians(Startwinkel))
TypeError: radians() takes no arguments (1 given)

We würde den das mit dem import dann aussehen, was bräuchte ich für diese Definition?

MfG Roter Drache

[BlackVivi]

Da die Funktion radians aus math auf jedenfall Argumente erwartet, schätze ich das du irgendwas falsch gemacht hast :3 Die Funktion überschrieben, schätze ich mal.

Code: Alles auswählen

In [4]: import math

In [5]: help(math.radians)
Help on built-in function radians in module math:

radians(...)
    radians(x) -> converts angle x from degrees to radians


In [6]: math.radians(0.2)
Out[6]: 0.0034906585039886592

Namespaces are one honking great idea -- let's do more of those!

(import this <-- more than an easter-egg :3)

[Roter Drache]

Hallo ihr Lieben,

Code: Alles auswählen

def Ellipse(XPosition,YPosition,XRadius,YRadius,Startwinkel,Endwinkel,Schritte):
    tracer(False)
    penup()
    dx=XRadius*math.cos(math.radians(Startwinkel))
    dy=YRadius*math.sin(math.radians(Startwinkel))
    goto(XPosition+dx,YPosition+dy)
    pendown()
    Winkel=(Endwinkel-Startwinkel)/Schritte
    for i in range(Schritte):
        dx=XRadius*math.cos(math.radians(i+1)*Winkel)
        dy=YRadius*math.sin(math.radians(i+1)*Winkel)
        goto(XPosition+dx,YPosition+dy)
    penup()
    goto(XPosition,YPosition)
    pendown()
    tracer(True)

Habe den ganzen Quatsch mir nochmal angeguckt und ein paar Fehler gefunden und aus gemerzt UND natürlich das mit dem math.... gemacht und siehe da es geht. Danke euch für die schnelle Hilfe :)

MfG Roter Drache

[stagger]

Hallo zusammen,

ich habe leider ein ähnliches Problem, jedoch nicht mit math.py sondern einer selbst geschriebenen Klasse. Obwohl ich die Funktion, die ohne Argumente definiert ist, auch ohne Argumente aufrufe, glaubt Python es sei ganz anders. Da komm ich nicht mehr ganz mit.

Ich habe mich schon gefragt, ob es daran liegt, dass die Funktion in jeder der Klassen unter dem gleichen Namen vorkommt, aber das dürfte wegen unterschiedlicher Namespaces doch eigentlich nicht sein, oder?

Code: Alles auswählen

class SalesOrder:
    [...]
    def get_opstring():
        [...]
[...]
print test_SO.get_opstring()

Und hier die komplette Datei: http://rafb.net/p/ICbEz391.html

Zum Verständnis:
1. Mit Erstellung eines Sales Order Objektes wird es mit Daten vom SQL-Server gefüllt und greift sich die darin enthaltenen Positionen.
2. Die einzelnen Positionen werden wieder Objekte. Jede Position hat einen Produktcode, jeder Productcode hat ein Produktblatt (BOM).
3. Aus dem Produktcode wird ein BOM-Objekt erstellt, das rekursiv die zur Herstellung benötigten Komponenten wiederum als BOM erstellt.
4. Mit Aufruf von get_opstring() werden alle zur Herstellung der Sales Order nötigen Produktionsschritte (kodiert) als String zurückgegeben. Hierbei wird folgendermaßen aufgelöst: Sales Order => SO Item => BOM => Komponenten => ...

Vielen Dank im voraus! Komme da einfach nicht weiter

[stagger]

Ok, ganz blöder Fehler: "self" als Argument vergessen. D'Oh!

Welchen Sinn hat es eigentlich, dass self immer das erste Argument sein muss? Oder anders: wo macht es Sinn, innerhalb einer Klasse self weg zu lassen?

[BlackJack]

Bei `staticmethod()`\s muss man das kein Argument für die Instanz haben und bei `classmethod()`\s heisst das Argument für die Klasse per Konvention `cls`.

Wenn man das `self` in einer Methode gar nicht benötigt, ist das ein guter Zeitpunkt sich zu fragen, ob das nicht einfach nur eine Funktion ist, die nicht unbedingt in die Klasse gehört.

[stagger]

Wenn man das `self` in einer Methode gar nicht benötigt, ist das ein guter Zeitpunkt sich zu fragen, ob das nicht einfach nur eine Funktion ist, die nicht unbedingt in die Klasse gehört.

Steht der Zwang, das Argument innerhalb einer Klasse zu verwenden, obwohl cls-lose Funktionen innerhalb einer Klasse keinen Sinn haben, nicht im Widerspruch zu Pythons Zielen, möglichst einfach und übersichtlich zu sein? Ich dachte Python möchte einem möglichst viel (unnötige) Schreibarbeit abnehmen.

[Rebecca]

Ich dachte Python möchte einem möglichst viel (unnötige) Schreibarbeit abnehmen.

Du verwechselst das mit Perl.

Verstaendlichkeit des Quellcodes steht nicht im Zusammenhang mit Kuerze des Quellcodes.

[BlackJack]

@stagger: Irgendwie verstehe ich Deine letzte Frage nicht!? Welcher Zwang? Und/oder wie soll das anders aussehen?

[stagger]

Was spräche dagegen, bei Funktionen innerhalb einer Klasse als erstes Argument automatisch self anzunehmen, d.h. diese Konvention über Bord zu werfen? Ich verstehe nicht, was für einen Sinn es überhaupt hat, bei jeder Funktion innerhalb einer Klasse die Instanz als Argument übergeben zu müssen. Gibt es einen Fall, in dem man folgenden Aufruf sich nicht auf die Instanz "test" bezogen haben möchte?

test.funktion()

Es widerspricht einfach (meinem Gefühl von) allgemeinem Menschenverstand, eine Funktion mit einem Argument (self) zu definieren, sie jedoch ohne dieses aufzurufen. Zur Lesbarkeit des Codes trägt es meiner Ansicht nach nicht bei, eher zur Verwirrung.

[BlackJack]

Wie willst Du in einer Methode ohne `self` wissen ob es sich um einen lokalen Namen oder um ein Attribut handelt?

Wenn es `self` als Argument nicht gäbe, würden die Leute als erstes anfangen eine Namenskonvention einzuführen, dass Attribute mit einem `m_`-Präfix versehen werden sollten, damit man den Quelltext leichter versteht.

Technisch gesehen rufst Du auch nicht die Funktion auf, sondern eine gebundene Methode. Wobei das gebunden eben gerade bedeutet, dass das erste Argument der Funktion an die Instanz gebunden wurde und damit die Methode ein Argument weniger hat.

Code: Alles auswählen

In [133]: A.foo
Out[133]: <unbound method A.foo>

In [134]: a.foo
Out[134]: <bound method A.foo of <__main__.A object at 0x98a5b0c>>

Was man auch bedenken muss ist, dass es dadurch möglich ist beliebige Funktionen dynamisch an Klassen zu binden. Wenn der Compiler an der Stelle schon eine Unterscheidung zwischen Funktionen und Methoden machen müsste, ginge das nicht mehr.

Irgendwo hast Du immer "Magie", entweder ein `self`, dass scheinbar auch dem "nichts" kommt, oder eben ein explizites `self` in der Signatur, dass man aber $GOTT sei Dank nicht *zweimal* übergeben muss. Denn bei ``test.funktion()`` gibst Du das erste Argument ja durchaus an, nur eben nicht in den Klammern, sondern vor dem Punktoperator.

[stagger]

OK, hab's verstanden Danke!

[BlackVivi]

Außerdem wüsste ich einen Fall, wo man self auf keinem Fall braucht (ein wenig verpöhnt, weil man ja namespaces sozusagen auch in Dateien definieren kann, aber es ist eine Möglichkeit!):

Code: Alles auswählen

class namespace:
    @staticmethod
    def statisch(foobar):
        return foobar*2

print namespace.statisch(2)

Also self hat schon sehr wohl einen Sinn.