Ticket #9725: tour_help.rst

File tour_help.rst, 9.6 KB (added by phil, 9 years ago)
Line 
1.. _chapter-help:
2
3Hilfe erhalten
4==============
5
6Sage hat eine umfassende eingebaute Dokumentation, auf die zugegriffen
7werden kann, indem der Name der Funktion oder Konstanten (zum
8Beispiel), gefolgt von einem Fragezeichen eingegeben wird:
9
10.. skip
11
12::
13
14    sage: tan?
15    Type:        <class 'sage.calculus.calculus.Function_tan'>
16    Definition:  tan( [noargspec] )
17    Docstring:
18   
19        The tangent function
20   
21        EXAMPLES:
22            sage: tan(pi)
23            0
24            sage: tan(3.1415)
25            -0.0000926535900581913
26            sage: tan(3.1415/4)
27            0.999953674278156
28            sage: tan(pi/4)
29            1
30            sage: tan(1/2)
31            tan(1/2)
32            sage: RR(tan(1/2))
33            0.546302489843790
34    sage: log2?
35    Type:        <class 'sage.functions.constants.Log2'>
36    Definition:  log2( [noargspec] )
37    Docstring:
38   
39        The natural logarithm of the real number 2.
40       
41        EXAMPLES:
42            sage: log2
43            log2
44            sage: float(log2)
45            0.69314718055994529
46            sage: RR(log2)
47            0.693147180559945
48            sage: R = RealField(200); R
49            Real Field with 200 bits of precision
50            sage: R(log2)
51            0.69314718055994530941723212145817656807550013436025525412068
52            sage: l = (1-log2)/(1+log2); l
53            (1 - log(2))/(log(2) + 1)
54            sage: R(l)
55            0.18123221829928249948761381864650311423330609774776013488056
56            sage: maxima(log2)
57            log(2)
58            sage: maxima(log2).float()
59            .6931471805599453
60            sage: gp(log2)
61            0.6931471805599453094172321215             # 32-bit
62            0.69314718055994530941723212145817656807   # 64-bit
63    sage: sudoku?
64    File:        sage/local/lib/python2.5/site-packages/sage/games/sudoku.py
65    Type:        <type 'function'>
66    Definition:  sudoku(A)
67    Docstring:
68   
69        Solve the 9x9 Sudoku puzzle defined by the matrix A.
70   
71        EXAMPLE:
72            sage: A = matrix(ZZ,9,[5,0,0, 0,8,0, 0,4,9, 0,0,0, 5,0,0,
73        0,3,0, 0,6,7, 3,0,0, 0,0,1, 1,5,0, 0,0,0, 0,0,0, 0,0,0, 2,0,8, 0,0,0,
74        0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0,   0,3,0, 0,0,2,
75        0,0,0, 4,9,0, 0,5,0, 0,0,3])
76            sage: A
77            [5 0 0 0 8 0 0 4 9]
78            [0 0 0 5 0 0 0 3 0]
79            [0 6 7 3 0 0 0 0 1]
80            [1 5 0 0 0 0 0 0 0]
81            [0 0 0 2 0 8 0 0 0]
82            [0 0 0 0 0 0 0 1 8]
83            [7 0 0 0 0 4 1 5 0]
84            [0 3 0 0 0 2 0 0 0]
85            [4 9 0 0 5 0 0 0 3]
86            sage: sudoku(A)
87            [5 1 3 6 8 7 2 4 9]
88            [8 4 9 5 2 1 6 3 7]
89            [2 6 7 3 4 9 5 8 1]
90            [1 5 8 4 6 3 9 7 2]
91            [9 7 4 2 1 8 3 6 5]
92            [3 2 6 7 9 5 4 1 8]
93            [7 8 2 9 3 4 1 5 6]
94            [6 3 5 1 7 2 8 9 4]
95            [4 9 1 8 5 6 7 2 3]
96
97Sage stellt auch eine 'Tab-Vervollständigung' zur Verfügung: schreiben Sie die
98ersten Buchstaben einer Funktion und drücken sie danach die Tabulatortaste.
99Wenn Sie zum Beispiel ``ta`` gefolgt von ``TAB`` eingeben, wird Sage
100``tachyon, tan, tanh, taylor`` ausgeben. Dies ist eine gute
101Möglichkeit den Namen von Funktionen, und anderen Strukturen, in Sage herauszufinden.
102
103
104.. _section-functions:
105
106Funktionen, Einrückungen, und Zählen
107====================================
108
109Um in Sage eine neue Funktion zu definieren, können Sie den ``def``
110Befahl und einen Doppelpunkt nach der Liste der Variablenname
111benutzen. Zum Beispiel:
112
113::
114
115    sage: def is_even(n):
116    ...       return n%2 == 0
117    ...
118    sage: is_even(2)
119    True
120    sage: is_even(3)
121    False
122
123Anmerkung: Abhängig von der Version des Tutorials, das Sie gerade lesen,
124sehen Sie vielleicht drei Punkte ``...`` in der zweiten Zeile dieses
125Beispiels. Tippen Sie diese nicht; Sie sind nur da, um zu
126verdeutlichen, dass der Code eingerückt ist. Wannimmer dies der Fall
127ist, drücken Sie [Return/Enter] einmal am Ende des Blocks um eine
128Leerzeile einzufügen und die Funktionsdefinition zu beenden.
129
130Sie bestimmen den Typ ihrer Eingabeargumente nicht. Sie können mehrere
131Argumente festlegen, jedes davon kann einen optionalen Defaultwert haben.
132Zum Beispiel wird in der Funktion unterhalb standardmäßig der Wert
133``divisor=2`` benutzt, falls ``divisor`` nicht angegeben wurde.
134
135::
136
137    sage: def is_divisible_by(number, divisor=2):
138    ...       return number%divisor == 0
139    sage: is_divisible_by(6,2)
140    True
141    sage: is_divisible_by(6)
142    True
143    sage: is_divisible_by(6, 5)
144    False
145
146Sie können auch ein oder mehrere Eingabeargumente explizit angeben
147wenn Sie die Funktion aufrufen; Wenn Sie die Eingaben explizit
148angeben, können Sie ihnen eine beliebige Reihenfolge geben:
149
150.. link
151
152::
153
154    sage: is_divisible_by(6, divisor=5)
155    False
156    sage: is_divisible_by(divisor=2, number=6)
157    True
158
159In Python werden Codeblöcke nicht mit geschweiften Klammern oder
160"begin-" und "end-Blöcken" kenntlich gemacht. Stattdessen werden
161Codeblöcke durch Einrückungen bestimmt, welche exakt zusammenpassen
162müssen. Zum Beispiel ist das Folgende ein Syntaxfehler, da die
163``return`` Anweisung nicht genauso weit eingerückt ist wie die anderen
164Zeilen zuvor.
165
166.. skip
167
168::
169
170    sage: def even(n):
171    ...       v = []
172    ...       for i in range(3,n):
173    ...           if i % 2 == 0:
174    ...               v.append(i)
175    ...      return v
176    Syntax Error:
177           return v
178
179Wenn Sie die Einrückung korrigieren, funktioniert die Funktion:
180
181::
182
183    sage: def even(n):
184    ...       v = []
185    ...       for i in range(3,n):
186    ...           if i % 2 == 0:
187    ...               v.append(i)
188    ...       return v
189    sage: even(10)
190    [4, 6, 8]
191
192Semikolons sind an den Zeilenenden nicht notwendig; Sie können jedoch
193mehrere Anweisungen, mit Semikolons getrennt, in eine Zeile schreiben:
194
195::
196
197    sage: a = 5; b = a + 3; c = b^2; c
198    64
199
200Falls Sie möchten, dass sich eine einzelne Codezeile über mehrere
201Zeilen erstreckt, können Sie einen terminierenden Backslash verwenden:
202
203::
204
205    sage: 2 + \
206    ...      3
207    5
208
209In Sage, können Sie zählen indem Sie über einen Zahlenbereich
210iterieren. Zum Beispiel ist nächste Zeile unterhalb gleichwertig zu
211``for(i=0; i<3; i++)`` in C++ oder Java:
212
213::
214
215    sage: for i in range(3):
216    ...       print i
217    0
218    1
219    2
220
221Die nächste Zeile unterhalb ist gleichwertig zu ``for(i=2;i<5;i++)``.
222
223::
224
225    sage: for i in range(2,5):
226    ...       print i
227    2
228    3
229    4
230
231Das dritte Argument bestimmt die Schrittweite, also ist das Folgende
232gleichwertig zu
233``for(i=1;i<6;i+=2)``.
234
235::
236
237    sage: for i in range(1,6,2):
238    ...       print i
239    1
240    3
241    5
242
243Oft will man eine schöne Tabelle erstellen, um die mit Sage
244berechneten Zahlen auszugeben. Eine einfache Möglichkeit dies zu tun
245ist String-Formatierung zu verwenden. Unten erstellen wir drei Spalten,
246jede genau 6 Zeichen breit, und erzeugen somit eine Tabelle mit
247Quadrat- und Kubikzahlen.
248
249::
250
251    sage: for i in range(5):
252    ...       print '%6s %6s %6s'%(i, i^2, i^3)
253         0      0      0
254         1      1      1
255         2      4      8
256         3      9     27
257         4     16     64
258
259Die elementarste Datenstruktur in Sage, ist die Liste. Die ist -- wie
260der Name schon sagt -- nichts anderes als eine Liste beliebiger
261Objekte. Zum Beispiel erzeugt der ``range`` Befehl, den wir schon
262verwendet haben, eine Liste:
263
264::
265
266    sage: range(2,10)
267    [2, 3, 4, 5, 6, 7, 8, 9]
268
269Hier ist eine etwas komplizierte Liste:
270
271::
272
273    sage: v = [1, "hello", 2/3, sin(x^3)]
274    sage: v
275    [1, 'hello', 2/3, sin(x^3)]
276
277Listenindizierung beginnt, wie in vielen Programmiersprachen, bei 0.
278
279.. link
280
281::
282
283    sage: v[0]
284    1
285    sage: v[3]
286    sin(x^3)
287
288Benutzen Sie ``len(v)`` um die Länge von ``v`` zu erhalten, benutzen
289Sie ``v.append(obj)`` um ein neues Objekt an das Ende von ``v``
290anzuhängen, und benutzen Sie ``del v[i]`` um den :math:`i^{ten}`
291Eintrag von ``v`` zu löschen:
292
293.. link
294
295::
296
297    sage: len(v)
298    4
299    sage: v.append(1.5)
300    sage: v
301    [1, 'hello', 2/3, sin(x^3), 1.50000000000000]
302    sage: del v[1]
303    sage: v
304    [1, 2/3, sin(x^3), 1.50000000000000]
305
306Eine weitere wichtige Datenstruktur ist das Dictionary (oder
307assoziativer Array). Dies funktioniert wie eine Liste, außer dass
308es mit fast jeden Objekt indiziert werden kann (die Indizes müssen
309jedoch unveränderbar sein):
310
311::
312
313    sage: d = {'hi':-2,  3/8:pi,   e:pi}
314    sage: d['hi']
315    -2
316    sage: d[e]
317    pi
318
319Sie können auch neue Datentypen definieren, indem Sie Klassen
320verwenden. Mathematische Objekte mit Klassen zusammenzufassen ist eine
321mächtige Technik, die dabei helfen kann Sage-Programme zu vereinfachen
322und zu organisieren. Unten definieren wir eine Klasse, die die Liste
323der geraden Zahlen bis *n* darstellt;
324Sie wird von dem Standard-Typ ``list`` abgeleitet.
325
326::
327
328    sage: class Evens(list):
329    ...       def __init__(self, n):
330    ...           self.n = n
331    ...           list.__init__(self, range(2, n+1, 2))
332    ...       def __repr__(self):
333    ...           return "Even positive numbers up to n."
334
335Die ``__init__`` Methode wird aufgerufen um das Objekt zu
336initialisieren, wenn es erzeugt wird; die ``__repr__`` Method gibt
337einen Objekt-String aus. Wir rufen die Listen-Konstruktor-Methode in
338der zweite Zeile der ``__init__`` Methode. Ein Objekt der Klasse
339``Evens`` erzeugen wir wie folgt:
340
341.. link
342
343::
344
345    sage: e = Evens(10)
346    sage: e
347    Even positive numbers up to n.
348
349Beachten Sie, dass die Ausgabe von ``e`` die ``__repr__`` Methode
350verwendet, die wir definiert haben. Um die eigentliche Liste
351sehen zu können, benutzen wir die ``list`` Function:
352
353.. link
354
355::
356
357    sage: list(e)
358    [2, 4, 6, 8, 10]
359
360Wir können auch das ``n`` Attribut verwenden oder ``e`` wie eine Liste
361behandeln.
362
363.. link
364
365::
366
367    sage: e.n
368    10
369    sage: e[2]
370    6