Commit 49d52d07 authored by Jakob Beetz's avatar Jakob Beetz
Browse files

Einführung Woche 1

parent cdcb507b
%% Cell type:markdown id: tags:
# Willkommen
# Python: erste Schritte
Dies ist ein interaktives Notebook um den Einstig in das Programmieren mit Python zu begleiten.
Jede Zelle kann interaktiv ausgeführt werden, in dem entweder das ▶ - Symbol in der oberen Leiste mit der Maus gewählt wird, oder die Tasten-Kombination <kbd>⇧ Shift</kbd><kbd>Enter</kbd> in der Zeile ausgeführt werden.
Probieren Sie es aus: Setzten Sie den Cursor in Zelle [2] mit dem Inhalt `1 + 2` und drücken Sie <kbd>⇧ Shift</kbd><kbd>Enter</kbd>
%% Cell type:code id: tags:
``` python
1 + 2
```
%%%% Output: execute_result
3
%% Cell type:markdown id: tags:
Das Ergenis sollte in der Zeile darunter erscheinen. Ein Notebook funktioniert analog zu einer Kommandozeile in der ein interaktiver Python Interpreter, die sog. [REPL-Umgebung](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) läuft.
Oft werden hier einzelne Ausgaben von Text, Variablen-Werten wie Ergebnissen ausgegeben. Dazu wird die `print` Funktion ausgeführt, die fest in Python eingebaut ist:
%% Cell type:code id: tags:
``` python
print("Hallo Python")
```
%%%% Output: stream
Hallo Python
%% Cell type:markdown id: tags:
In diesem Falle wurde die Zeichenkette `Hello Python` als sog. Parameter and die Funktion übergeben. Zeichenketten werden mit `"` begonnen und beendet.
%% Cell type:markdown id: tags:
## Variablen und Datentypen
Statt ein Ergebnis einfach nur zu berechnen und in der Konsole oder dem Notebook auszugeben, können wir den Wert auch einer Variblen zuweisen. Der Python-Interpreter sucht dabei automatisch den passenden Datenytpen aus:
%% Cell type:code id: tags:
``` python
Ergebnis = 1 + 2
print(Ergebnis)
Ergebnis
```
%%%% Output: stream
%%%% Output: execute_result
3
%% Cell type:markdown id: tags:
### Variablenamen
%% Cell type:markdown id: tags:
Es können beliebig viele Variablen in ein Skript eingefügt werden. Variablen müssen eindeutige Namen haben
%% Cell type:markdown id: tags:
### Datentypen
%% Cell type:markdown id: tags:
Jede Variable in Python hat einen Datentypen. Streng genommen ist jeder Datentyp in Python selber ein Objekt
%% Cell type:code id: tags:
``` python
Ergebnis = 3 * 5
type(Ergebnis)
```
%%%% Output: execute_result
int
%% Cell type:markdown id: tags:
Jedes mal wenn ein neuer Wert einer vorhandenen Variablen zugewiesen wird, kann sich der Datentyp ändern. Hier wird `Ergebnis` zu einer Gleitkommazahl vom Typ `float`
%% Cell type:code id: tags:
``` python
Ergebnis = 3.5 / 5
type(Ergebnis)
```
%%%% Output: execute_result
float
%% Cell type:markdown id: tags:
Datentypen können explizit angegeben werden:
%% Cell type:code id: tags:
``` python
f = float(1)
f
```
%%%% Output: execute_result
1.0
%% Cell type:code id: tags:
``` python
type(f)
```
%%%% Output: execute_result
float
%% Cell type:code id: tags:
``` python
ganzzahl_pi = int(3.14)
ganzzahl_pi
```
%%%% Output: execute_result
3
%% Cell type:code id: tags:
``` python
type(ganzzahl_pi)
```
%%%% Output: execute_result
int
%% Cell type:markdown id: tags:
# Textausgabe und Zeichenketten
%% Cell type:markdown id: tags:
Variablen können mit `print()` ausgegeben werden:
%% Cell type:code id: tags:
``` python
help(int)
Ergebnis = 3 * 5
print(Ergebnis)
```
%%%% Output: stream
Help on class int in module builtins:
class int(object)
| int([x]) -> integer
| int(x, base=10) -> integer
|
| Convert a number or string to an integer, or return 0 if no arguments
| are given. If x is a number, return x.__int__(). For floating point
| numbers, this truncates towards zero.
|
| If x is not a number or if base is given, then x must be a string,
| bytes, or bytearray instance representing an integer literal in the
| given base. The literal can be preceded by '+' or '-' and be surrounded
| by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
| Base 0 means to interpret the base from the string as an integer literal.
| >>> int('0b100', base=0)
| 4
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __and__(self, value, /)
| Return self&value.
|
| __bool__(self, /)
| self != 0
|
| __ceil__(...)
| Ceiling of an Integral returns itself.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(...)
| Flooring an Integral returns itself.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(self, format_spec, /)
| Default object formatter.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __invert__(self, /)
| ~self
|
| __le__(self, value, /)
| Return self<=value.
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __or__(self, value, /)
| Return self|value.
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rand__(self, value, /)
| Return value&self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __ror__(self, value, /)
| Return value|self.
|
| __round__(...)
| Rounding an Integral returns itself.
| Rounding with an ndigits argument also returns an integer.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __sizeof__(self, /)
| Returns size in memory, in bytes.
|
| __str__(self, /)
| Return str(self).
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| __xor__(self, value, /)
| Return self^value.
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| to_bytes(self, /, length, byteorder, *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_bytes(bytes, byteorder, *, signed=False) from builtins.type
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.
| Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number
15
%% Cell type:markdown id: tags:
Wird einer vorhandenen Variablen ein neuer Wert zugewiesen, wird der alte Inhalt unwiederbringlich mit dem neuen Wert überschrieben:
Variablen Werte, die keine Strings sind können durch Formatierungsstrings ausgegeben werden.
Verschiedenen Ansätze habe sich im Lauf der Zeit entwickelt.
Der traditionelle Weg is über das `%` Zeichen. Dieser findet sich noch häufig in älterem Quellcode, ist aber nicht mehr empfohlen:
%% Cell type:code id: tags:
``` python
Ergebnis = 2 * 5
print (Ergebnis)
print ("Das Ergebnis lautet: %s!" % Ergebnis)
```
%%%% Output: stream
10
Das Ergebnis lautet: 3!
%% Cell type:markdown id: tags:
Der moderne Weg ab Python 3 ist über sogenannte Formatstring `F-Strings`
Dabei wird dem String ein `f` vorangestellt. Innerhalb des String können dann Variablen in `{` und `}` eingefügt werden.
%% Cell type:code id: tags:
``` python
print(f"Das Ergebnis ist {Ergebnis}. Immer noch")
```
%%%% Output: stream
Das Ergebnis ist 3. Immer noch
%% Cell type:markdown id: tags:
Hier können auch kleiner Operationen ausgeführt oder Funktionen aufgerufen werden:
%% Cell type:code id: tags:
``` python
print (f"Spontane Berechnung: {4*5}")
```
%%%% Output: stream
Spontane Berechnung: 20
%% Cell type:code id: tags:
``` python
zahl = 1 / 3
print (f"Zahl ohne Begrenzung:\t {zahl}")
print (f"Zahl mit Begrenzung:\t {zahl:.4f}")
print (f"Zentriert: \t\t {zahl:^20.3f}")
```
%%%% Output: stream
Zahl ohne Begrenzung: 0.3333333333333333
Zahl mit Begrenzung: 0.3333
Zentriert: 0.333
......
%% Cell type:code id: tags:
``` python
from ipycanvas import Canvas
canvas = Canvas(width=200, height=200)
canvas.stroke_style = 'blue'
canvas.stroke_line(0, 0, 0, 150)
canvas.stroke_line(0, 150, 225, 225)
canvas.stroke_line(0, 0, 150, 300)
canvas.stroke_line(0, 0, 150, 150)
canvas.stroke_line(0, 0, 150, 150)
canvas.stroke_style = 'red'
canvas.stroke_line(200, 0, 0, 200)
canvas.stroke_style = 'green'
canvas.stroke_line(150, 150, 0, 200)
canvas.rotate(1.4)
canvas
```
%%%% Output: display_data
%% Cell type:code id: tags:
``` python
def handle_touch_move(fingers_locations):
# Draw circles where fingers are located
for finger_location in fingers_locations:
canvas.fill_arc(finger_location[0], finger_location[1], 6, 0, 2 * pi)
canvas.on_touch_move(handle_touch_move)
```
%% Cell type:code id: tags:
``` python
def handle_mouse_move(x, y):
# Do something
pass
canvas.on_mouse_move(handle_mouse_move)
def handle_mouse_down(x, y):
# Do something else
pass
canvas.on_mouse_down(handle_mouse_down)
canvas.scale(0.1,1)
canvas.stroke_line(0, 150, 225, 225)
canvas.stroke_line(0, 0, 150, 300)
canvas.stroke_line(0, 0, 150, 150)
canvas.stroke_line(0, 0, 150, 150)
canvas
```
%%%% Output: display_data
%% Cell type:code id: tags:
``` python
from io import BytesIO
import cairo
import IPython.display
svgio = BytesIO()
with cairo.SVGSurface(svgio, 200, 200) as surface:
# These lines are copied verbatim from the
# pycairo page: https://pycairo.readthedocs.io
context = cairo.Context(surface)
x, y, x1, y1 = 0.1, 0.5, 0.4, 0.9
x2, y2, x3, y3 = 0.6, 0.1, 0.9, 0.5
context.scale(200, 200)
context.set_line_width(0.04)
context.move_to(x, y)
context.curve_to(x1, y1, x2, y2, x3, y3)
context.stroke()
context.set_source_rgba(1, 0.2, 0.2, 0.6)
context.set_line_width(0.02)
context.move_to(x, y)
context.line_to(x1, y1)
context.move_to(x2, y2)
context.line_to(x3, y3)
context.stroke()
# end of pycairo copy
IPython.display.SVG(data=svgio.getvalue())
```
%%%% Output: error
---------------------------------------------------------------------------
ModuleNotFoundError Traceback (most recent call last)
<ipython-input-7-29d1d2f3d453> in <module>
1 from io import BytesIO
2
----> 3 import cairo
4 import IPython.display
5
ModuleNotFoundError: No module named 'cairo'
%% Cell type:code id: tags:
``` python
from bokeh.plotting import figure, output_file, show
output_file("toolbar.html")
# create a new plot with the toolbar below
p = figure(plot_width=400, plot_height=400,
title=None, toolbar_location="below")
p.circle([1, 2, 3, 4, 5], [2, 5, 8, 2, 7], size=10)
show(p)
```
%%%% Output: error
---------------------------------------------------------------------------
ModuleNotFoundError Traceback (most recent call last)
<ipython-input-8-084bba4bac9d> in <module>
----> 1 from bokeh.plotting import figure, output_file, show
2
3 output_file("toolbar.html")
4
5 # create a new plot with the toolbar below
ModuleNotFoundError: No module named 'bokeh'
%% Cell type:code id: tags:
``` python
from ipycanvas import Canvas
canvas = Canvas(width=200, height=150)
def perform_drawings():
canvas.font = '32px serif'
canvas.fill_text('Voilà!', 100, 50)
canvas.on_client_ready(perform_drawings)
canvas
```
%%%% Output: display_data
%% Cell type:code id: tags:
``` python
import turtle
star = turtle.Turtle()
for i in range(100):
star.forward(100)