MPK23-Zwischenlager: Difference between revisions

From Attraktor Wiki
Jump to navigation Jump to search
← Older edit
No edit summary
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
= Diese Seite dient zum Zwischenspeichern von Artikeln für den Micropythonkurs 2023=
= Diese Seite dient zum Zwischenspeichern von Artikeln für den Micropythonkurs 2023=
== Slicing==
== Funktionen==
==== Positions- oder Schlüsselwortargumente====
** https://realpython.com/python-asterisk-and-slash-special-parameters/
** https://medium.com/@mr.stucknet/a-roadmap-to-python-parameter-definitions-best-practices-and-beyond-6faa2f66fc19
 
== Namensräume==
<pre>
<pre>
The basics of slicing
Python-Namespace – Die Psychologie hinter der dynamischen Programmierung
 
Rinu Gour
My good friend John has a very long name:
PythonFlood
Rinu Gour


John Alexander Harrington Fitzsimmons O'Leary Smith.
·
Folgen


Quite a mouthful, hun?!
Veröffentlicht in
PythonFlood


Well, let's put these names into a list:
·
5 Minuten gelesen
·
23. Mai
43


>>> names = "John Alexander Harrington Fitzsimmons O'Leary Smith".split()
>>> names
['John', 'Alexander', 'Harrington', 'Fitzsimmons', "O'Leary", 'Smith']


Using indexing, we can easily access whichever single name we want.


For example, we can easily access John's first or last names:


>>> names[0]
'John'
>>> names[-1]
'Smith'


(If you didn't know you could use the index -1 to fetch the last element of a list, you must read this ASAP!)


Now, if you want to get the two first names, the four surnames, or the four middle names, you need to use sequence slicing.
Python ist eine weit verbreitete High-Level-Programmiersprache, die aufgrund ihrer Einfachheit und Flexibilität an Popularität gewonnen hat. Es bietet verschiedene Funktionen, die das Schreiben und Verstehen von Code erleichtern. Eine dieser Funktionen ist das Konzept von Namespace und Scope.


By definition, “sequence slicing” is the means through which you can access multiple consecutive positions of a sequence, like a list.
In Python ist jede Variable, Funktion und jedes Objekt in einem bestimmten Namensraum definiert und hat einen bestimmten Gültigkeitsbereich. Für jeden Python-Programmierer ist es von entscheidender Bedeutung zu verstehen, wie Namespaces und Bereiche funktionieren.


Here is an example to extract John's two first names:
Python-Namespace und -Bereich
Was ist Namespace?
In Python ist ein Namespace im Wesentlichen ein Container, der eine Reihe von Namen oder Bezeichnern zusammen mit den entsprechenden Objekten enthält. Stellen Sie sich das wie ein Verzeichnis vor, das Dateien enthält – der Namespace enthält die Namen und Objekte und das Verzeichnis enthält die Dateien.


>>> names[0:2]
Der Hauptzweck eines Namespace besteht darin, jedem Objekt in einem Programm einen eindeutigen Namen zu geben, damit die Objekte leicht identifiziert und darauf zugegriffen werden kann.
['John', 'Alexander']


Rumours say that's the code that governments all over the world use to generate the section “First names” for the passports and national identity cards of their citizens.
Arten von Namespaces:
In Python gibt es zwei Arten von Namespaces: Lokal und Global.


The example above shows that the square brackets [], that you also use for indexing, are used for slicing.
1. Lokaler Namespace:
Ein lokaler Namespace wird bei jedem Aufruf einer Funktion erstellt und enthält alle Namen oder Bezeichner, die innerhalb dieser Funktion definiert sind.


We typically think of the slicing integers in terms of [start : stop], because the first index tells Python where to start and the second one tells Python where to stop:
Auf den lokalen Namespace kann nur innerhalb der Funktion zugegriffen werden, und daran vorgenommene Änderungen werden außerhalb der Funktion nicht widergespiegelt.


    start is the index of the first element to include in the result – names[0] is "John"
Hier ist ein Beispiel eines von PythonFlood geschriebenen lokalen Namespace:
    stop is the index of the first element that is not included in the result – names[2] is "Harrington" but the last name in the result of names[0:2] was "Alexander"


This may look confusing at first, but this diagram should clear any doubts you might have and also provides a good mnemonic so you never forget how this works.
def my_function ():
    x = 10
    print (x)
   
my_function ()
In diesem Beispiel enthält der lokale Namespace nur einen Namen – „x“, der den Wert 10 hat. Wenn die Funktion aufgerufen wird, wird der Wert von „x“ auf der Konsole ausgegeben.


When the first integer of the slice is 0, it can be omitted.
Sobald die Ausführung der Funktion abgeschlossen ist, wird der lokale Namespace zerstört.


This means that names[0:2] and names[:2] is equivalent.
2. Globaler Namespace:
Ein globaler Namespace wird erstellt, wenn ein Modul importiert oder definiert wird, und er enthält alle Namen oder Bezeichner, die außerhalb von Funktionen definiert werden.


Similarly, if you want the slice to go all the way to the end of the sequence, you can omit the stop index.
Dies bedeutet, dass der globale Namespace im gesamten Programm zugänglich ist und alle Änderungen, die an den Namen oder Objekten im globalen Namespace vorgenommen werden, überall widergespiegelt werden.


To give you an example of this, I'll tell you some inside information I got from a friend.
Hier ist ein Beispiel für einen globalen Namespace:


There are rumours that the function below is used by governments from all over the world to generate the section of “Surnames” on the passports of their citizens:
x = 10


def surnames(names):
def my_function ():  
     return names[2:]
     print ( x )
   
my_function ()
In diesem Beispiel enthält der globale Namespace nur einen Namen – „x“, der den Wert 10 hat. Wenn die Funktion aufgerufen wird, wird der Wert von „x“ auf der Konsole ausgegeben. Da „x“ im globalen Namespace definiert ist, kann die Funktion darauf zugreifen. Alle Änderungen an „x“ innerhalb der Funktion wirken sich auch auf den Wert von „x“ außerhalb der Funktion aus.


print(surnames(names))
Beispiel aus der Praxis mit Namespace:
# ['Harrington', 'Fitzsimmons', "O'Leary", 'Smith']
Nehmen wir an, Sie sind Lehrer und möchten die Noten Ihrer Schüler im Auge behalten. Sie könnten ein Programm erstellen, das Namespaces verwendet, um die Namen und Noten der Schüler zu speichern.


Slices are objects, too!
Der globale Namespace würde die Namen der Schüler enthalten, während der lokale Namespace die Noten für jeden Schüler enthalten würde.


I had been using slicing for a long time when I learned something crazy about slicing.
Hier ist ein von PythonFlood geschriebenes Beispiel:


Slices – the numbers you type separated by colons :, are actually Python objects!
Students = [ 'John' , 'Mary' , 'Bob' ]


You can create a slice and use it to perform slicing operations:
def  grades ():  
    john_grade = 85
    mary_grade = 92
    bob_grade = 78
    print (students[ 0 ] + ': ' + str (john_grade))
    print (students[ 1 ] + ': ' + str (mary_grade))
    print (students[ 2 ] + ': ' + str (bob_grade))
   
grades()
In diesem Beispiel enthält der globale Namespace die Liste der Schüler, während der lokale Namespace die Noten für jeden Schüler enthält. Die Funktion „grades()“ gibt den Namen und die Note jedes Schülers auf der Konsole aus.


>>> names[slice(1, -1)]
Da die Namen der Schüler im globalen Namensraum gespeichert sind, kann die Funktion auf sie zugreifen. Die Noten hingegen werden im lokalen Namespace gespeichert und sind nur innerhalb der Funktion zugänglich.
['Alexander', 'Harrington', 'Fitzsimmons', "O'Leary"]


Isn't this surprising?!
Regeln für die Namensraum- und Bereichsauflösung
Wenn es um die Namensraum- und Bereichsauflösung in Python geht, sind einige wichtige Regeln zu beachten:


It blew my mind when I found out for the first time.
Python verwendet eine LEGB-Regel (Local, Enclosing, Global, Built-in), um Namespaces und Bereiche aufzulösen. Python sucht nach einer referenzierten Variablen zuerst im lokalen Namespace, dann in allen umschließenden Namespaces, dann im globalen Namespace und schließlich im integrierten Namespace, der die integrierten Funktionen und Module von Python enthält.
Wenn eine Variable in einer Funktion definiert ist, wird davon ausgegangen, dass sie sich im lokalen Namensraum dieser Funktion befindet. Python sucht zunächst im lokalen Namensraum nach einer Variablen. Wenn sie nicht lokal definiert ist, sucht sie im umschließenden Namensraum ( (falls vorhanden) und fahren Sie in der Kette fort, bis die Variable gefunden wird oder der globale Namespace erreicht wird.
Wenn Sie eine Variable in einer Funktion definieren, wird sie standardmäßig als im lokalen Namespace liegend betrachtet. Um eine globale Variable innerhalb einer Funktion zu ändern, verwenden Sie das Schlüsselwort global, um anzugeben, dass die globale Variable verwendet werden soll, anstatt eine neue lokale Variable zu erstellen.
Hier ist ein Beispiel, das diese von PythonFlood geschriebenen Regeln veranschaulicht:


But then again...
x = 1


Everything in Python is an object, so maybe I shouldn't have been so surprised!
def  foo ():
    x = 2
    print ( "Inside foo:" , x)


Now, if slices are objects, then you can name them too!
def  bar ():
    global x
    x = 3
    print ( "Inside bar:" , x)


Here is a slice that drops the first element of any list:
foo()
print ( "Outside foo: " , x)
bar()
print ( "Outside bar:" , x)
In diesem Beispiel definieren wir eine globale Variable x mit dem Wert 1. Anschließend definieren wir zwei Funktionen, foo und bar. foo erstellt eine neue Variable x mit dem Wert 2 in ihrem lokalen Namensraum und gibt sie aus. bar verwendet das Schlüsselwort global, um die globale Variable x zu ändern und auf 3 zu setzen.


>>> drop_first = slice(1, None)
Wenn wir foo aufrufen, gibt es den Wert von x in seinem lokalen Namensraum (der 2 ist) aus, aber wenn wir den Wert von x außerhalb von foo ausdrucken, sehen wir, dass er immer noch den Wert 1 hat. Das liegt daran, dass foo hat eine neue lokale Variable x erstellt, anstatt die globale Variable zu ändern.
>>> names[drop_first]
['Alexander', 'Harrington', 'Fitzsimmons', "O'Leary", 'Smith']
>>> ["first", "second", "third"][drop_first]
['second', 'third']


Take a moment to let that sink in!
Wenn wir bar aufrufen, ändert es die globale Variable x so, dass sie einen Wert von 3 hat. Wenn wir den Wert von x außerhalb von bar ausgeben, sehen wir, dass er auf 3 geändert wurde.


With named slices, you could rewrite the government code we saw above:
Best Practices für Namespace und Scope
Hier sind einige Best Practices für die Verwendung von Namespaces und Bereichen in Ihrem Python-Code:


>>> first_names = slice(None, 2)
Vermeiden Sie nach Möglichkeit die Verwendung globaler Variablen. Globale Variablen können das Lesen und Debuggen Ihres Codes erschweren, da es schwierig sein kann, den Überblick darüber zu behalten, wo eine Variable geändert wird.
>>> surnames = slice(2, None)
Verwenden Sie beschreibende Variablennamen, um deutlich zu machen, wofür jede Variable verwendet wird. Dies kann dazu beitragen, Namenskonflikte zu vermeiden und Ihren Code verständlicher zu machen.
>>> names[first_names]
Verwenden Sie Funktionen und Klassen, um Code zu kapseln und Namensraumverschmutzung zu vermeiden. Indem Sie verwandten Code in Funktionen und Klassen gruppieren, können Sie die Anzahl der Variablen im globalen Namespace minimieren und die Überlegungen zu Ihrem Code erleichtern.
['John', 'Alexander']
Vermeiden Sie die Verwendung von Wildcard-Importen (vom Modulimport *), da diese zu Namenskonflikten führen und das Aufspüren von Fehlern erschweren können.
>>> names[surnames]
Hier ist ein Beispiel dafür, wie Sie diese von PythonFlood geschriebenen Best Practices befolgen können:
['Harrington', 'Fitzsimmons', "O'Leary", 'Smith']


Named slices aren't seen very often in the wild because most programmers just learn about the sequence slicing idioms.
def  berechne_durchschnittlich ( Zahlen ):
    „““
    Berechnen Sie anhand einer Liste von Zahlen den Durchschnitt und geben Sie ihn zurück.
    „““
    total = sum (Zahlen)
    count = len (Zahlen)
    Durchschnitt = total / count
Zusammenfassend lässt sich sagen, dass das Verständnis des Konzepts von Namespace und Scope in Python für jeden Programmierer, der effizienten und effektiven Code schreiben möchte, von entscheidender Bedeutung ist. Namespaces und Scopes bieten eine Möglichkeit, Variablen und Funktionen in einem Python-Programm zu organisieren und darauf zuzugreifen.


However, I find that slicing is the perfect example of what “everything in Python is an object” means.
Durch das Verständnis der verschiedenen Arten von Namespaces und Bereichen sowie der Lösungsregeln können Programmierer Namenskonflikte vermeiden und sicherstellen, dass ihr Code reibungslos läuft.


If this piqued your interest, I've written about the inner workings of sequence slicing on my blog, so feel free to take a look!
Best Practices für die Namensraum- und Bereichsverwaltung, wie die Vermeidung globaler Variablen und die Verwendung beschreibender Namenskonventionen, können ebenfalls dazu beitragen, die Lesbarkeit und Wartbarkeit von Code zu verbessern.


Finally, I need to disclose that this email essentially copied the subject that my good friend Stephen wrote about very recently.
Insgesamt sind Namespaces und Bereiche wichtige Konzepte, die jeder Python-Programmierer verstehen muss, der hochwertigen, gut strukturierten Code schreiben möchte.
 
When I saw Stephen's email I jumped on my seat because I really like the fact that you can name slices.
 
So, thank you, Stephen!
 
By the way, you can also influence what I write about.
 
If there is something you'd like me to write about, reply to this email and I'll see what I can do.
ICYMI
 
In Case You Missed It, over the past few days I rewrote an article I have about about list comprehensions 101.
 
Now it has better examples, better diagrams, and some nice animations that show how everything works.
 
​Take a look and let me know if you have any suggestions for improvements.
</pre>
</pre>
== Funktionen==
==== Positions- oder Schlüsselwortargumente====
** https://realpython.com/python-asterisk-and-slash-special-parameters/
** https://medium.com/@mr.stucknet/a-roadmap-to-python-parameter-definitions-best-practices-and-beyond-6faa2f66fc19


== Navigation==
== Navigation==

Latest revision as of 18:05, 1 October 2023

Diese Seite dient zum Zwischenspeichern von Artikeln für den Micropythonkurs 2023

Funktionen

Positions- oder Schlüsselwortargumente

Namensräume

Python-Namespace – Die Psychologie hinter der dynamischen Programmierung
Rinu Gour
PythonFlood
Rinu Gour

·
Folgen

Veröffentlicht in
PythonFlood

·
5 Minuten gelesen
·
23. Mai
43






Python ist eine weit verbreitete High-Level-Programmiersprache, die aufgrund ihrer Einfachheit und Flexibilität an Popularität gewonnen hat. Es bietet verschiedene Funktionen, die das Schreiben und Verstehen von Code erleichtern. Eine dieser Funktionen ist das Konzept von Namespace und Scope.

In Python ist jede Variable, Funktion und jedes Objekt in einem bestimmten Namensraum definiert und hat einen bestimmten Gültigkeitsbereich. Für jeden Python-Programmierer ist es von entscheidender Bedeutung zu verstehen, wie Namespaces und Bereiche funktionieren.

Python-Namespace und -Bereich
Was ist Namespace?
In Python ist ein Namespace im Wesentlichen ein Container, der eine Reihe von Namen oder Bezeichnern zusammen mit den entsprechenden Objekten enthält. Stellen Sie sich das wie ein Verzeichnis vor, das Dateien enthält – der Namespace enthält die Namen und Objekte und das Verzeichnis enthält die Dateien.

Der Hauptzweck eines Namespace besteht darin, jedem Objekt in einem Programm einen eindeutigen Namen zu geben, damit die Objekte leicht identifiziert und darauf zugegriffen werden kann.

Arten von Namespaces:
In Python gibt es zwei Arten von Namespaces: Lokal und Global.

1. Lokaler Namespace:
Ein lokaler Namespace wird bei jedem Aufruf einer Funktion erstellt und enthält alle Namen oder Bezeichner, die innerhalb dieser Funktion definiert sind.

Auf den lokalen Namespace kann nur innerhalb der Funktion zugegriffen werden, und daran vorgenommene Änderungen werden außerhalb der Funktion nicht widergespiegelt.

Hier ist ein Beispiel eines von PythonFlood geschriebenen lokalen Namespace:

def my_function (): 
    x = 10 
    print (x) 
    
my_function ()
In diesem Beispiel enthält der lokale Namespace nur einen Namen – „x“, der den Wert 10 hat. Wenn die Funktion aufgerufen wird, wird der Wert von „x“ auf der Konsole ausgegeben.

Sobald die Ausführung der Funktion abgeschlossen ist, wird der lokale Namespace zerstört.

2. Globaler Namespace:
Ein globaler Namespace wird erstellt, wenn ein Modul importiert oder definiert wird, und er enthält alle Namen oder Bezeichner, die außerhalb von Funktionen definiert werden.

Dies bedeutet, dass der globale Namespace im gesamten Programm zugänglich ist und alle Änderungen, die an den Namen oder Objekten im globalen Namespace vorgenommen werden, überall widergespiegelt werden.

Hier ist ein Beispiel für einen globalen Namespace:

x = 10 

def my_function (): 
    print ( x ) 
    
my_function ()
In diesem Beispiel enthält der globale Namespace nur einen Namen – „x“, der den Wert 10 hat. Wenn die Funktion aufgerufen wird, wird der Wert von „x“ auf der Konsole ausgegeben. Da „x“ im globalen Namespace definiert ist, kann die Funktion darauf zugreifen. Alle Änderungen an „x“ innerhalb der Funktion wirken sich auch auf den Wert von „x“ außerhalb der Funktion aus.

Beispiel aus der Praxis mit Namespace:
Nehmen wir an, Sie sind Lehrer und möchten die Noten Ihrer Schüler im Auge behalten. Sie könnten ein Programm erstellen, das Namespaces verwendet, um die Namen und Noten der Schüler zu speichern.

Der globale Namespace würde die Namen der Schüler enthalten, während der lokale Namespace die Noten für jeden Schüler enthalten würde.

Hier ist ein von PythonFlood geschriebenes Beispiel:

Students = [ 'John' , 'Mary' , 'Bob' ] 

def  grades (): 
    john_grade = 85
     mary_grade = 92
     bob_grade = 78 
    print (students[ 0 ] + ': ' + str (john_grade)) 
    print (students[ 1 ] + ': ' + str (mary_grade)) 
    print (students[ 2 ] + ': ' + str (bob_grade)) 
    
grades()
In diesem Beispiel enthält der globale Namespace die Liste der Schüler, während der lokale Namespace die Noten für jeden Schüler enthält. Die Funktion „grades()“ gibt den Namen und die Note jedes Schülers auf der Konsole aus.

Da die Namen der Schüler im globalen Namensraum gespeichert sind, kann die Funktion auf sie zugreifen. Die Noten hingegen werden im lokalen Namespace gespeichert und sind nur innerhalb der Funktion zugänglich.

Regeln für die Namensraum- und Bereichsauflösung
Wenn es um die Namensraum- und Bereichsauflösung in Python geht, sind einige wichtige Regeln zu beachten:

Python verwendet eine LEGB-Regel (Local, Enclosing, Global, Built-in), um Namespaces und Bereiche aufzulösen. Python sucht nach einer referenzierten Variablen zuerst im lokalen Namespace, dann in allen umschließenden Namespaces, dann im globalen Namespace und schließlich im integrierten Namespace, der die integrierten Funktionen und Module von Python enthält.
Wenn eine Variable in einer Funktion definiert ist, wird davon ausgegangen, dass sie sich im lokalen Namensraum dieser Funktion befindet. Python sucht zunächst im lokalen Namensraum nach einer Variablen. Wenn sie nicht lokal definiert ist, sucht sie im umschließenden Namensraum ( (falls vorhanden) und fahren Sie in der Kette fort, bis die Variable gefunden wird oder der globale Namespace erreicht wird.
Wenn Sie eine Variable in einer Funktion definieren, wird sie standardmäßig als im lokalen Namespace liegend betrachtet. Um eine globale Variable innerhalb einer Funktion zu ändern, verwenden Sie das Schlüsselwort global, um anzugeben, dass die globale Variable verwendet werden soll, anstatt eine neue lokale Variable zu erstellen.
Hier ist ein Beispiel, das diese von PythonFlood geschriebenen Regeln veranschaulicht:

x = 1 

def  foo (): 
    x = 2 
    print ( "Inside foo:" , x) 

def  bar (): 
    global x 
    x = 3 
    print ( "Inside bar:" , x) 

foo() 
print ( "Outside foo: " , x) 
bar() 
print ( "Outside bar:" , x)
In diesem Beispiel definieren wir eine globale Variable x mit dem Wert 1. Anschließend definieren wir zwei Funktionen, foo und bar. foo erstellt eine neue Variable x mit dem Wert 2 in ihrem lokalen Namensraum und gibt sie aus. bar verwendet das Schlüsselwort global, um die globale Variable x zu ändern und auf 3 zu setzen.

Wenn wir foo aufrufen, gibt es den Wert von x in seinem lokalen Namensraum (der 2 ist) aus, aber wenn wir den Wert von x außerhalb von foo ausdrucken, sehen wir, dass er immer noch den Wert 1 hat. Das liegt daran, dass foo hat eine neue lokale Variable x erstellt, anstatt die globale Variable zu ändern.

Wenn wir bar aufrufen, ändert es die globale Variable x so, dass sie einen Wert von 3 hat. Wenn wir den Wert von x außerhalb von bar ausgeben, sehen wir, dass er auf 3 geändert wurde.

Best Practices für Namespace und Scope
Hier sind einige Best Practices für die Verwendung von Namespaces und Bereichen in Ihrem Python-Code:

Vermeiden Sie nach Möglichkeit die Verwendung globaler Variablen. Globale Variablen können das Lesen und Debuggen Ihres Codes erschweren, da es schwierig sein kann, den Überblick darüber zu behalten, wo eine Variable geändert wird.
Verwenden Sie beschreibende Variablennamen, um deutlich zu machen, wofür jede Variable verwendet wird. Dies kann dazu beitragen, Namenskonflikte zu vermeiden und Ihren Code verständlicher zu machen.
Verwenden Sie Funktionen und Klassen, um Code zu kapseln und Namensraumverschmutzung zu vermeiden. Indem Sie verwandten Code in Funktionen und Klassen gruppieren, können Sie die Anzahl der Variablen im globalen Namespace minimieren und die Überlegungen zu Ihrem Code erleichtern.
Vermeiden Sie die Verwendung von Wildcard-Importen (vom Modulimport *), da diese zu Namenskonflikten führen und das Aufspüren von Fehlern erschweren können.
Hier ist ein Beispiel dafür, wie Sie diese von PythonFlood geschriebenen Best Practices befolgen können:

def  berechne_durchschnittlich ( Zahlen ): 
    „““ 
    Berechnen Sie anhand einer Liste von Zahlen den Durchschnitt und geben Sie ihn zurück. 
    „““
     total = sum (Zahlen) 
    count = len (Zahlen) 
    Durchschnitt = total / count
Zusammenfassend lässt sich sagen, dass das Verständnis des Konzepts von Namespace und Scope in Python für jeden Programmierer, der effizienten und effektiven Code schreiben möchte, von entscheidender Bedeutung ist. Namespaces und Scopes bieten eine Möglichkeit, Variablen und Funktionen in einem Python-Programm zu organisieren und darauf zuzugreifen.

Durch das Verständnis der verschiedenen Arten von Namespaces und Bereichen sowie der Lösungsregeln können Programmierer Namenskonflikte vermeiden und sicherstellen, dass ihr Code reibungslos läuft.

Best Practices für die Namensraum- und Bereichsverwaltung, wie die Vermeidung globaler Variablen und die Verwendung beschreibender Namenskonventionen, können ebenfalls dazu beitragen, die Lesbarkeit und Wartbarkeit von Code zu verbessern.

Insgesamt sind Namespaces und Bereiche wichtige Konzepte, die jeder Python-Programmierer verstehen muss, der hochwertigen, gut strukturierten Code schreiben möchte.

Navigation

Zurück zu Micropython Kurs 2023 - Teil 1
Zurück zur "Micropython Kurs 2023" Startseite
Zurück zur Programmieren Startseite
Zurück zur Wiki Startseite

Retrieved from "https://wiki.attraktor.org/index.php?title=MPK23-Zwischenlager&oldid=38995"