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
radians () error
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.
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
- Python-Forum Veteran
- Beiträge: 5555
- Registriert: Samstag 28. Februar 2004, 22:04
- Wohnort: Oberhofen im Inntal (Tirol)
- Kontaktdaten:
Hallo Roter Drache!Roter Drache hat geschrieben:die math.py lade ich mit
from math import *
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
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
-
- User
- Beiträge: 3
- Registriert: Dienstag 20. November 2007, 22:08
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 :
so und dort bekomme ich immer die Fehlermeldung
MfG Roter Drache
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()
We würde den das mit dem import dann aussehen, was bräuchte ich für diese Definition?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)
MfG Roter Drache
Zuletzt geändert von Roter Drache am Dienstag 20. November 2007, 23:44, insgesamt 1-mal geändert.
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
(import this <-- more than an easter-egg :3)Namespaces are one honking great idea -- let's do more of those!
-
- User
- Beiträge: 3
- Registriert: Dienstag 20. November 2007, 22:08
Hallo ihr Lieben,
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
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)
MfG Roter Drache
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?
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
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()
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
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?
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?
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.
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.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.
- Rebecca
- User
- Beiträge: 1662
- Registriert: Freitag 3. Februar 2006, 12:28
- Wohnort: DN, Heimat: HB
- Kontaktdaten:
Du verwechselst das mit Perl.stagger hat geschrieben:Ich dachte Python möchte einem möglichst viel (unnötige) Schreibarbeit abnehmen.
Verstaendlichkeit des Quellcodes steht nicht im Zusammenhang mit Kuerze des Quellcodes.
Offizielles Python-Tutorial (Deutsche Version)
Urheberrecht, Datenschutz, Informationsfreiheit: Piratenpartei
Urheberrecht, Datenschutz, Informationsfreiheit: Piratenpartei
@stagger: Irgendwie verstehe ich Deine letzte Frage nicht!? Welcher Zwang? Und/oder wie soll das anders aussehen?
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.
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.
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.
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.
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>>
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.
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!):
Also self hat schon sehr wohl einen Sinn.
Code: Alles auswählen
class namespace:
@staticmethod
def statisch(foobar):
return foobar*2
print namespace.statisch(2)