Skip to content
Snippets Groups Projects
Commit 7bddd2ae authored by Daniel Hahn's avatar Daniel Hahn
Browse files

added Einheit 09

parent 7b668cf9
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Semester_2/Einheit_07/Uebung_6_LSG.ipynb 0 → 100644
+ 446
− 0
View file @ 7bddd2ae
%% Cell type:markdown id:d24fe0d8 tags:
# <font color='blue'>**Übung 6 - Datenanalyse - Pandas**</font>
(Diese Übung gehört zur Vorlesungseinheit 7)
## <font color='blue'>**Problemstellung: Erstellen und Modifizieren eines Pandas-Datensatzes**</font>
In der letzten Übung wurde ein großer Datensatz eingelesen und viel analysiert. Im Gegensatz dazu, wird in dieser kürzeren Übung ein kleiner Datensatz angelegt, modifiziert und weniger Auswertungen gemacht. Diese Übung sollte auf jeden Fall selbst ausprobiert werden, bevor die Lösung betrachtet wird.
### <font color='blue'>**Problembeschreibung**</font>
Folgende Ergebisse einer Umfrage einer Umfrage liegen vor. Dieser Datensatz soll manuell als Dataframe angelegt werden. Es gibt 6 Personen (um nicht so viel eintragen zu müssen) und 3 Fragen. Die erste Frage ist nur eine ja/nein Frage, die anderen Fragen haben Punkte zwischen 1 und 5.
| Person | Frage 1 | Frage 2 | Frage 3 |
|---|---|---|---|
| Person 1 | ja | 3 | 5 |
| Person 2 | ja | 1 | 1 |
| Person 3 | nein | 3 | 4 |
| Person 4 | nein | 2 | 4 |
| Person 5 | ja | 2 | 5 |
| Person 6 | ja | 4 | 2 |
Erstelle einen Pandas Dataframe mit den vorliegenden Daten. Die Spalte Person soll dabei der Index sein, die Fragenbezeichnung der Spaltenname.
Erstelle nun mithilfe von Pandas Auswertungen: Durchschnittswerte der Fragen und Diagramme, wie viele Personen die Punktzahl vergeben haben (vgl. Histogramm).
Erstelle zum Schluss eine neue Spalte/Serie mit der durchschnittlichen Bewertung der beiden Punktefragen (pro Person). Ggf. musst du auf den index achten. Gibt es eine Korrelation zwischen der Antwort auf Frage 2 und der durchschnittlichen Bewertung?
### <font color='blue'>**Umsetzung**</font>
%% Cell type:markdown id:b802cb5f tags:
Dataframe:
%% Cell type:code id:76d8f081 tags:
``` python
import pandas as pd
F1 = pd.Series([True, True, False, False, True, True])
F2 = pd.Series([3,1,3,2,2,4])
F3 = pd.Series([5,1,4,4,5,2])
df = pd.DataFrame(data={"Frage 1":F1,"Frage 2":F2,"Frage 3":F3})
df.index = ["Person 1", "Person 2", "Person 3", "Person 4", "Person 5", "Person 6"]
df
```
%% Output
Frage 1 Frage 2 Frage 3
Person 1 True 3 5
Person 2 True 1 1
Person 3 False 3 4
Person 4 False 2 4
Person 5 True 2 5
Person 6 True 4 2
%% Cell type:markdown id:e1a6aca4 tags:
Durchschnitte
%% Cell type:code id:8cd5023d tags:
``` python
df.mean()
```
%% Output
Frage 1 0.666667
Frage 2 2.500000
Frage 3 3.500000
dtype: float64
%% Cell type:markdown id:f12a6ac9 tags:
Plot:
%% Cell type:code id:bfc83f6d tags:
``` python
df["Frage 3"].plot(kind="hist")
```
%% Output
<AxesSubplot:ylabel='Frequency'>
%% Cell type:markdown id:54426b00 tags:
Durchschnittliche Punktzahl pro Person:
%% Cell type:code id:59f2f5c6 tags:
``` python
mean = (F2+F3)/2
mean.index = ["Person 1", "Person 2", "Person 3", "Person 4", "Person 5", "Person 6"]
df["Durchschnitt"] = mean
df
```
%% Output
Frage 1 Frage 2 Frage 3 Durchschnitt
Person 1 True 3 5 4.0
Person 2 True 1 1 1.0
Person 3 False 3 4 3.5
Person 4 False 2 4 3.0
Person 5 True 2 5 3.5
Person 6 True 4 2 3.0
%% Cell type:markdown id:53d382b2 tags:
Korrelation:
%% Cell type:code id:3e1f3b22 tags:
``` python
df.corr()
```
%% Output
Frage 1 Frage 2 Frage 3 Durchschnitt
Frage 1 1.000000e+00 8.199540e-17 -0.235702 -0.184637
Frage 2 8.199540e-17 1.000000e+00 0.174078 0.636364
Frage 3 -2.357023e-01 1.740777e-01 1.000000 0.870388
Durchschnitt -1.846372e-01 6.363636e-01 0.870388 1.000000
Semester_2/Einheit_09/Grundlagen-Networking.ipynb 0 → 100644
+ 498
− 0
View file @ 7bddd2ae
%% Cell type:markdown id:f0b13807-b3b2-4f55-9581-9f8d4ffaa3b5 tags:
## <font color='blue'>**Grundlagen Netzwerke**</font>
Zweck von Netzwerken und deren Technologien:
* **Datenaustausch**: Innerhalb eines Netzwerkes können Daten/Dateien auf andere Rechner transferiert werden. Diese Daten stehen dann mehreren Personen auch auf anderen Computern zur Verfügung.
* **Ressourcenteilung**: Speicher, CPU, Drucker, Faxgeräte, Scanner, Internetzugänge, ... aber auch Anwendungen können gemeinsam genutzt werden.
* **Administration**: Computer in einem Netzwerk können zentral ggf. mit spezieller Software einfach administriert und gewartet werden.
* **Kommunikation**: Informationsaustausch von Computer zu Computer durch Kommunikationsanwendungen: Video-, Telefonanwendungen, E-Mail-Programme …
Für die Umsetzung ist es notwendig, Konventionen für die genutzten Medien zum Zweck des Transfer von Daten/Informationen zwischen Sender und Empfänger zu vereinbaren, d.h. **Protokolle**
### <font color='blue'>**Netzwerk-Referenzmodelle**</font>
Unter einem Protokoll werden diverse Datenstrukturen und Konventionen,
wie der Ablauf der Kommunikation stattfindet, z.B. Folge von Nachrichten, und wie die Informationen jeweils zu interpretieren sind, z.B. Syntax der Nachrichten.
In der Netzwerktechnologie wird das Prinzip der Schichtung verfolgt.
D.h. jede Schicht repräsentiert eine Abstraktionsebene, jede Schicht führt eine wohldefinierte Funktion aus,
es gibt nur schmale Schnittstellen zwischen Schichten, um Informationsfluss zu minimieren. Ziel ist es, die Komplexität eines offenen Rechnernetzes zu reduzieren.
Die Funktion der einzelnen Schicht ist aufgrund von international spezifizierten Standardprotokollen definiert.
Beispiele sinf die ISO/OSI Protokollfamilie und darin enthalten die TCP/IP Protokollsuite als de-facto Standard.
<div>
<img src="./Pics/Netzwerkschichten.png" width="801"/>
</div>
* **Netzzugriff**:
Übertragung von Dateneinheiten unter Zeitbedingungen zwischen zwei benachbarten Rechnern, transparente Übertragung von Bitsequenzen,
Berücksichtigung der Eigenschaften der Übertragungsmodi (elektrisch, Lichtwelle), Zusammenfassung von Bitsequenzen zu Rahmen (Frames), Fehlererkennung und Fehlerkorrektur auf Rahmenebene.
<br>
Adressierung über die **MAC-Adresse** (Media-Access-Control)
* **Internet**:
fehlerfreie Übermittlung einer Nachricht von einem Endrechner, über ein Netz von Routern (Vermittlungsrechnern) hinweg, bis hin zum zweiten Endrechner,
Zusammenschaltung von Teilstrecken zu einer End-zu-End Verbindung, Wegewahl und Vermittlung, Transporteinheit abhängig von der Vermittlungstechnik (bei Paketvermittlung: Pakete)
<br>
Adressierung über die **IP-Adresse** (IPv4 32bit / IPv6 128bit) mit der Trennung in den Netzwerk und Hostteil. Beispiel:
| Adresse | Wert |
|--------|------|
|IP-Adresse: | 130.94.122.195 |
|Netzmaske (16 gesetzte Bits): | 255.255.0.0 |
|Netzwerkteil: | 130.94.0.0 |
|Broadcastadresse: | 130.94.255.255 |
|Mögliche Adressen: | 130.94.0.1 – 130.94.255.254 |
* **Transport**:
fehlerfreier Transport zwischen zwei Prozessen auf zwei Endrechnern, bildet die anwendungs-orientierten Schichten auf die netzabhängigen Schichten ab
netzunabhängiger Transport von Nachrichten zwischen zwei Endsystemen, passt die vom Anwendungssystem geforderte Übertragungsqualität an die vom darunterliegenden Transportnetz angebotene Übertragungsqualität an. Beispiele: Transmission Control Protocol (**TCP**), User Datagram Protocol (**UDP**)
<br>
Adressierung über die **Portnummer** (16 Bits) als Verbindung zum Programm.
* **Anwendung**:
Verschiedene Applikationsdienst-Elemente verfügbar, Auswahl hängt von den ablaufenden Anwendungen ab, z.B.
Dateizugriff (SFTP), Fernverarbeitung (telnet / Port 23 oder ssh / Port 22), Elektronische Post (SMTP / Port 25), Name Service (DNS), WWW (HTTP / Port 80)
%% Cell type:markdown id:deda85ec-34da-4e96-8778-8865406f95a1 tags:
### <font color='blue'>**HTTP-Protokoll**</font>
HTTP steht für Hypertext Transfer Protocol) und befindet sich in der Anwendungsschicht
Es dient der Übertragung von Daten und ist der Standard im World Wide Web (WWW) zur Übertragung von Webseiten.
Die Webbrowser greifen fast ausschließlich mit diesem Protokoll auf Web-Server zu.
#### <font color='blue'>**Ablauf einer HTTP-Transaktion (Request / Response)**</font>
* Client baut eine Verbindung zum Server auf. Meist geschieht das über TCP/IP.
* Ist Verbindung da, schickt Client eine Datei-Anfrage (Request) an Server. Die Anfrage ist normaler Text (Zahlen, Zeichen und einige Sonderzeichen).
* Server hat anschließend die Möglichkeit zu antworten: z.B. der angeforderte Dateiinhalt oder eine Fehlermeldung.
<div>
<img src="./Pics/HTTP.png" width="801"/>
</div>
##### <font color='blue'>**Request**</font>
Zeile 1: Wie: GET , Was: /index.html , HTTP-Versionsnummer der Anfrage <br>
Header: Zusatzinformationen zur Verarbeitung, Verbindung oder gewünschten Dateiformaten
GET /index.html HTTP/1.1
Host: www.html-world.de
User-Agent: Mozilla/4.0
Accept: image/gif, image/jpeg, */*
Connection: Keep-Alive
##### <font color='blue'>**Response**</font>
Zeile 1: Zu verwendende HTTP-Version und Response-Code: Übertragungsstatus <br>
Header: Zusatzinfos zur Übertragung, dem Dokument etc., dann Leerzeile, Dokumenteninhalt
HTTP/1.1 200 OK
Date: Thu, 15 Jul 2004 19:20:21 GMT
Server: Apache/1.3.5 (Unix)
Accept-Ranges: bytes
Content-length: 46
Connection: close
Content-type: text/html
<h1>Antwort</h1>
<p>Ich bin eine Antwort</p>
Die Client-Server-Verbindung bleibt solange aufrecht, bis **eine Transaktion** abgeschlossen ist, d.h. bis zur Antwort des Servers.
Prinzipiell ist aber auch eine persistente Verbindung möglich.
Request-Methoden (Auswahl)
* `GET, HEAD` – Download, Abfragen von Dokumenteneigenschaften
* `POST, PUT` – Upload von Antworten, Dokumenten
* `DELETE` – Löschen von Dokumenten
%% Cell type:markdown id:18634499-4294-4ec6-8dc4-c7014fc7ad79 tags:
### <font color='blue'>**XML-Extensible Markup Language**</font>
XML ist eine erweiterbare Auszeichnungssprache zur Repräsentation hierarchisch strukturierter, d.h. baumartig organisierter Daten im Format einer Textdatei.
Sie sollen sowohl Menschen als auch von Maschinen lesbar sein.
Die wichtigste Struktureinheit eines XML-Dokumentes ist das Element. Elemente sind die Träger der Information in einem XML-Dokument.
Elemente können Text wie auch weitere Elemente als Inhalt enthalten.
Elemente bilden die Knoten des Strukturbaumes eines XML-Dokumentes.
Der Name eines XML-Elementes kann in XML-Dokumenten ohne Dokumenttypdefinition (DTD) frei gewählt werden.
In XML-Dokumenten mit DTD muss der Name eines Elementes in der DTD deklariert sein und
das Element muss sich in einer zugelassenen Position innerhalb des Strukturbaumes gemäß DTD befinden.
In der DTD wird u. a. der mögliche Inhalt eines jeden Elementes definiert.
### <font color='blue'>**Aufbau**</font>
Jedes Element besitzt eine Auszeichnung mittels sogenannter Tags (Auszeichnungen):
* `<Elementname>`: Starttag für den Beginn eines Elementes
* `</Elementname>`: Endtag für das Ende eines Elementes
* `Attributname=Attributwert`: Attributen im Starttag zur Beschreibung weiterer Eigenschaften des Elements
* `<!-- Kommentar-Text -->`: Kommentare
* `<?Zielname Daten?>`: Verarbeitungsanweisungen
Beispiel:
<?xml version="1.0" encoding="ISO-8859-1"?>
<bookstore>
<book category="cooking">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book category="children">
<title lang="en">Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="web">
<title lang="en">Learning XML</title>
<author>Erik T. Ray</author>
<year>2003</year>
<price>39.95</price>
</book>
</bookstore>
### <font color='blue'>**XML-Familie**</font>
Einige XML-Ausprägungen:
* Text: DocBook, HTML
* Graphik: SVG, X3D
* Geodaten: GPX, OSM
* Multimedia: MPEG-7
* Ingenieurwissenschaften: AutomationML, CAEX
* Mathematik: MathML
Infratsruktur zur Handhabung von XML-Dokumenten:
* XSLT, STX: Transformation von XML-Dokumenten
* XPath: Adressierung von Teilen eines XML-Baumes
* XPointer, XLink und XInclude: Verknüpfung von XML-Ressourcen
* XQuery: Selektion von Daten aus einem XML-Datensatz
* XSD, DTD: Definition von XML-Datenstrukturen
* Signatur und Verschlüsselung von XML-Knoten: XML Signature und XML-Encryption
* ...
* Definition zum Methoden- bzw. Funktionsaufruf durch verteilte Systeme: XML-RPC
%% Cell type:markdown id:eee87805-5b67-40d9-be70-27c8aa623f04 tags:
### <font color='blue'>**XML-RPC**</font>
Der Standard XML-RPC (XML Remote Procedure Call) realisiert den entfernten Funktions- und Methodenaufruf über das Netzwerk als Client-Server-Lösung.
Die entfernten Funktionen können aus Sicht der Programmierung aufgerufen werden, als gehörten sie zum lokalen Programm.
Das Übertragen der Funktionsaufrufe, deren Parameter und des Rückgabewertes wird von der XML-RPC-Bibliothek übernommen
XML-RPC basiert auf zwei bereits existierenden Standards (XML und HTTP), so dass keine weiteren Protokolle einführt werden müssen.
Es ist daher einfach umzusetzbar und daher in vielen Programmiersprachen verfügbar.
XML-RPC ist unabhängig von einer bestimmten Programmiersprache entwickelt worden,
so dass Client und Server in zwei verschiedenen Sprachen implementiert werden können.
Bei der Spezifikation galt es, einen Mindeststandard zu definieren, der von den Programmiersprache erfüllt wird. Dies betritt besonders die im Standard verfügbaren Datentypen.
#### <font color='blue'>**XML-RPC-Server ... siehe Notebook Server**</font>
#### <font color='blue'>**XML-RPC-Client**</font>
Ein XML-RPC-Client wird mit der Klasse ServerProxy des Moduls xmlrpc.client realisiert:
* `ServerProxy(uri, [transport, encoding, verbose, allow_none, use_datetime])` Erzeugt eine Instanz der Klasse ServerProxy, die mit dem XML-RPC-Server mit der URI (Uniform Resource Identifier) verbunden ist
* `transport`: Backend.
* `verbose`: Ausgabe alle ausgehenden und ankommenden XML-Pakete auf dem Bildschirm, wenn True.
* `use_datetime`: Repräsentation von Datums- und Zeitangaben anstelle der xmlrpc.client-internen Klasse DateTime die Klasse datetime, wenn True.
* `encoding` und `allow_none`: gleiche Bedeutung wie der Klasse SimpleXMLRPCServer
Nach der Instanziierung der Klasse ServerProxy ist diese mit einem XML-RPC-Server verbunden und die beim Server registrierten Funktionen können aufrufen bzw. verwenden können.
Sind Server-seitig die Introspection-Funktionen vom Server zugelassen, können dies auch aufgerufen werden:
* `system.listMethods()`: Namen aller beim XML-RPC-Server registrierten entfernten Funktionen.
* `system.methodSignature(name)`: Auskunft über die Schnittstelle (Typen der Parameter) der registrierten Funktion mit dem Funktionsnamen `name`. Nur bei typgebunden Sprachen sinnvoll.
* `system.methodHelp(name)`: Liefert den Docstring der entfernten Funktion name zurück.
#### <font color='blue'>**Begrenzungen**</font>
Der XML-RPC-Standard ist nicht auf Python allein zugeschnitten, sondern es wurde bei der Ausarbeitung des Standards versucht, einen kleinsten gemeinsamen Nenner vieler Programmiersprachen zu finden, sodass beispielsweise Server und Client auch dann miteinander kommunizieren können, wenn sie in verschiedenen Sprachen geschrieben wurden.
Daher bringt die Verwendung von XML-RPC einige Einschränkungen mit sich, was die komplexeren bzw. exotischeren Datentypen von Python betrifft.
So gibt es im XML-RPC-Standard beispielsweise keine Repräsentation der Datentypen complex, set und frozenset. Eine Unterstützung besonderer Datentypen bedarf einer Abbildung der Typen auf die, die XML-RPC unterstützt.
Beispielsweise kann eine komplexe Zahl über eine XML-RPC-Schnittstelle geschickt werden, indem Sie Real- und Imaginärteil getrennt jeweils als Zahl übermitteln.
Folgende Datentypen sind im XML-RPC-Standard vorgesehenen:
| XML-RPC | Python |Anmerkungen|
|---|---|---|
|boolesche Werte|bool|–|
|ganze Zahlen|int|–|
|Gleitkommazahlen|float|–|
|Strings|str|–|
|Arrays|list|In der Liste dürfen als Elemente nur XML-RPC-konforme Instanzen verwendet werden.|
|Strukturen|dict|Alle Schlüssel müssen Strings sein. Als Werte dürfen nur XML-RPC-konforme Instanzen verwendet werden.|
|Datum/Zeit|DateTime|Der spezielle Datentyp xmlrpc.client.DateTime wird verwendet.|
|Binärdaten|Binary|Der spezielle Datentyp xmlrpc.client.Binary wird verwendet.|
|Nichts|None|Nur möglich, wenn der Client mit allow_none=True erzeugt wurde.|
|Gleitkommazahlen mit beliebiger Genauigkeit|decimal.Decimal|
%% Cell type:markdown id:3b15b3f5-501f-4948-9e69-d201084a91b1 tags:
#### <font color='blue'>**Beispiel für einen XML-RPC-Client**</font>
%% Cell type:code id:fc3dca97-85fd-4c40-a465-8b7c70a4e6ec tags:
``` python
import xmlrpc.client
hostAddress = '127.0.0.1'
hostPort = '12345'
URI = "http://" + hostAddress + ":" + hostPort
proxy = xmlrpc.client.ServerProxy(URI, verbose=False)
num1 = 9
num2 = 4
print('{} + {} is {}'.format(num1, num2, proxy.addition(num1, num2)))
print('{} - {} is {}'.format(num1, num2, proxy.subtraction(num1, num2)))
print('{} * {} is {}'.format(num1, num2, proxy.multiplication(num1, num2)))
print('{} / {} is {}'.format(num1, num2, proxy.division(num1, num2)))
```
%% Output
9 + 4 is 13
9 - 4 is 5
9 * 4 is 36
9 / 4 is 2.25
%% Cell type:markdown id:15e3ab96-34d5-4523-8553-204eea2b1f64 tags:
Kontroll-Output des Clients der ersten Server-Anfrage:
%% Cell type:code id:7103a2c0-d23d-4c81-81c3-ad8b322eb07b tags:
``` python
send: b'POST /RPC2 HTTP/1.1\r\n
Host: 127.0.0.1:12345\r\n
Accept-Encoding: gzip\r\n
Content-Type: text/xml\r\n
User-Agent: Python-xmlrpc/3.8\r\n
Content-Length: 192\r\n
\r\n'
send: b"<?xml version='1.0'?>\n
<methodCall>\n
<methodName>addition</methodName>\n
<params>\n
<param>\n
<value><int>9</int></value>\n
</param>\n
<param>\n
<value><int>4</int></value>\n
</param>\n
</params>\n
</methodCall>\n"
reply: 'HTTP/1.0 200 OK\r\n'
header: Server: BaseHTTP/0.6 Python/3.8.10
header: Date: Tue, 20 Jun 2023 13:18:08 GMT
header: Content-type: text/xml
header: Content-length: 122
body: b"<?xml version='1.0'?>\n
<methodResponse>\n
<params>\n
<param>\n
<value><int>13</int></value>\n
</param>\n
</params>\n
</methodResponse>\n"
```
%% Cell type:markdown id:400fae51-775e-4e8c-a6fd-f5052911593d tags:
Test der Server-Erweiterungen
%% Cell type:code id:4d3d1370-6dcd-4f90-85f0-f7f98e7be32c tags:
``` python
proxy = xmlrpc.client.ServerProxy(URI, verbose=False)
print(proxy.name())
print(proxy.helpMe())
print(proxy.system.listMethods())
print(proxy.system.methodHelp('add'))
print(proxy.serverTime())
```
%% Output
127.0.0.1
['add', 'addition_array', 'currentTime', 'division', 'getCount', 'getData', 'helpMe', 'multiplication', 'name', 'serverTime', 'subtraction', 'system.listMethods', 'system.methodHelp', 'system.methodSignature']
['add', 'addition_array', 'currentTime', 'division', 'getCount', 'getData', 'helpMe', 'multiplication', 'name', 'serverTime', 'subtraction', 'system.listMethods', 'system.methodHelp', 'system.methodSignature']
Addiert zwei Zahlen
11:08:42
%% Cell type:markdown id:b449453f-48ee-4f82-9164-0a860a52549c tags:
Test der Server-Erweiterungen für die numpy-Array Handhabung:
%% Cell type:code id:d0e26eb1-b1e8-4ece-b225-ce9c54cfa2a5 tags:
``` python
import numpy
proxy = xmlrpc.client.ServerProxy(URI, verbose=False)
num3 = numpy.array( [1.0,2.0,3.0] )
num4 = 10
print( numpy.array( proxy.addition_array( num3.tolist(), num3.tolist() ) ) )
```
%% Output
[2. 4. 6.]
%% Cell type:code id:9b2cf197-9769-438b-aacf-989dd58d34e9 tags:
``` python
Test der Servererweiterung mit Objekt-Methoden:
```
%% Cell type:code id:f7579dd1-37ab-413f-9449-338de21f0255 tags:
``` python
print(proxy.getCount(10))
print(proxy.getData())
print(proxy.getCount(10))
print(proxy.currentTime.getCurrentTime())
```
%% Output
1020
42
1021
20230621T11:12:20
Semester_2/Einheit_09/Grundlagen-Server.ipynb 0 → 100644
+ 283
− 0
View file @ 7bddd2ae
%% Cell type:markdown id:7671966d-f256-49ca-80c4-1d6181acc60a tags:
### <font color='blue'>**XML-RPC-Server**</font>
Der Server wird in der Regel mittels der Klasse `SimleXMLRPCServer` implementiert:
* `SimleXMLRPCServer(addr, [requestHandler, logRequests, allow_none, encoding, bind_and_activate])`
* `addr`: Spezifikation der IP-Adresse und des Ports als Tuple (ip, port), an die der Server gebunden wird.
* `requestHandler`: Backend, das eingehende Daten in einen Funktionsaufruf zurückzuverwandeln. default: SimpleXMLRPCRequestHandler
* `logRequest`: Protokollierung der einkommenden Funktionsaufrufe. default: True
* `allow_none`: erlaubt es `None` in XML-RPC-Funktionen zu verwenden. default: True
* `encoding`: Encoding zur Datenübertragung. default: UTF-8
* `bind_and_activate`: Bindung an Adresse direkt nach der Instanziierung. default: True
Methoden der Klasse `SimleXMLRPCServer`
* `s.register_function(function, [name])`:
Registrierung des Funktionsobjekts function für einen RPC-Aufruf. Optional: Name, über den die Funktion vom Client zu erreichen ist.
* `s.register_instance(instance, [allow_dotted_names])`:
Registrierung einer Instanz instance für den entfernten Zugriff.
Wenn der Client eine Methode dieser Instanz aufruft, wird der Aufruf durch die spezielle Methode _dispatch geleitet,
um den Aufruf einer Methode und ihren Parametern zuzuordnen.
* `s.register_introspection_functions()`:
Registrierung der Funktionen `system.listMethods`, `system.methodHelp` und `system.methodSignature` für den entfernten Zugriff.
* `s.register_multicall_functions()`:
Registrierung der Funktion `system.multicall`. Mit der Funktion `system.multicall` kann der Client mehrere Methodenaufrufe bündeln.
Auch die Rückgabewerte der Methodenaufrufe werden gebündelt zurückgegeben.
%% Cell type:markdown id:91376581-9808-4db2-840d-254291726be3 tags:
#### <font color='blue'>**Beispiel Server 1**</font>
%% Cell type:code id:8134ccc4-070a-4139-982d-d73d20f07d7d tags:
``` python
from xmlrpc.server import SimpleXMLRPCServer
hostAddress = '127.0.0.1'
port = '12345'
server = SimpleXMLRPCServer((hostAddress, int(port)))
server.register_introspection_functions()
def addition(x, y):
return x + y
def subtraction(x, y):
return x - y
def multiplication(x, y):
return x * y
def division(x, y):
try:
return x / y
except ZeroDivisionError:
return "Division durch 0!"
server.register_function(addition)
server.register_function(subtraction)
server.register_function(multiplication)
server.register_function(division)
server.serve_forever()
```
%% Cell type:markdown id:88535bd5-1e27-4b8a-9248-ba647794bdda tags:
#### <font color='blue'>**Beispiel Server 2**</font>
%% Cell type:code id:a0fb420b-4d4a-4458-8ddd-90be08643a90 tags:
``` python
import sys, time
import numpy
from xmlrpc.server import SimpleXMLRPCServer
hostAddress = '127.0.0.1'
port = '12345'
server = SimpleXMLRPCServer((hostAddress, int(port)))
server.register_introspection_functions()
def addition(x, y):
"""
Addiert zwei Zahlen
"""
return x + y
def subtraction(x, y):
return x - y
def multiplication(x, y):
return x * y
def division(x, y):
try:
return x / y
except ZeroDivisionError:
return "Division durch 0!"
server.register_function(addition, 'add')
server.register_function(subtraction)
server.register_function(multiplication)
server.register_function(division)
# Erweiterungen für Services
def name():
return hostAddress
def helpMe():
return server.system_listMethods()
def helpSignature(name):
return server.system.methodSignature(addition)
def serverTime():
return time.strftime("%H:%M:%S")
server.register_function(name)
server.register_function(helpMe)
server.register_function(serverTime)
# Erweiterung für numpy-Arrays
def addition_array(x, y):
if type(x) == list:
x = numpy.array( x )
if type(y) == list:
y = numpy.array( y )
z = x + y
if type( z ) == numpy.ndarray:
return z.tolist()
return z
server.register_function(addition_array)
# Erweiterungen für Methoden von Klassen-Objekten
import datetime
class ExampleService:
def __init__( self, count ):
self.count = count
def getData(self):
self.count += 1
return '42'
def getCount(self, value):
return value + self.count
class currentTime:
@staticmethod
def getCurrentTime():
return datetime.datetime.now()
exService = ExampleService(1000)
server.register_instance(exService, allow_dotted_names=True)
server.serve_forever()
```
%% Output
127.0.0.1 - - [21/Jun/2023 11:08:42] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:08:42] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:08:42] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:08:42] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:08:42] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:16] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:16] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:16] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:16] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:18] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:19] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:12:20] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:16:43] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:16:56] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:16:56] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:16:56] "POST /RPC2 HTTP/1.1" 200 -
127.0.0.1 - - [21/Jun/2023 11:16:56] "POST /RPC2 HTTP/1.1" 200 -
Semester_2/Einheit_09/Pics/HTTP.png 0 → 100644
+ 0
− 0
View file @ 7bddd2ae
Semester_2/Einheit_09/Pics/HTTP.png

76.8 KiB

Semester_2/Einheit_09/Pics/Netzwerkschichten.png 0 → 100644
+ 0
− 0
View file @ 7bddd2ae
Semester_2/Einheit_09/Pics/Netzwerkschichten.png

56.8 KiB

0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment