MPK23-Zwischenlager: Unterschied zwischen den Versionen

Aus Attraktor Wiki

Wechseln zu: Navigation, Suche
(→‎Für String Erweiterungen im Teil 2)
 
(7 dazwischenliegende Versionen des gleichen Benutzers werden nicht angezeigt)
Zeile 1: Zeile 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=
 +
== 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
  
−
== Für String Erweiterungen im Teil 2==
+
== Namensräume==
−
=== Formatierung===
+
−
Es gibt in Python 3 Arten Texte zu formatieren. In diesem Fall bedeutet das, Einfügen von Werten in einen bestehenden Text.
+
−
Davon stehen in Micropython nur die 2 älteren Methoden zur Verfügung. Die neueste, f-Formatierung genannt, gibt es in Micropython noch nicht.
+
−
Bei Internetsuchen zur Formatierung in Python stößt man inzwischen meist auf die f-Formatierung. Das ist für Micropython wenig hilfreich. Deshalb ist es sinnvoller nach %-Formatierung oder .format() zu suchen.
+
−
==== %-Formatierung====
+
−
Dieses ist die älteste Formatierung von Python. Deshalb werde ich darauf nicht weiter eingehen,
+
−
 
+
−
==== .format()-Formatierung====
+
−
Bei dieser Art der Formatierung wird als Platzhalter im Text {} eingesetzt. .format() ist eine Methode der Klasse string. Die einzusetzten Werte werden in der richtigen Reihenfolge als Parameter übergeben.
+
 
<pre>
 
<pre>
−
>>> text = 'Hallo {}, schön das Du da bist'.format('Peter')
+
Python-Namespace – Die Psychologie hinter der dynamischen Programmierung
−
>>> text
+
Rinu Gour
−
'Hallo Peter, sch\xf6n das Du da bist'
+
PythonFlood
−
>>> print(text)
+
Rinu Gour
−
Hallo Peter, schön das Du da bist
+
−
>>>
+
−
</pre>
+
−
===== Erweiterte Formatanweisungen=====
+
−
https://www.w3schools.com/python/ref_string_format.asp<br>
+
−
Es gibt weitere Möglichkeiten die eingefügten Werte zu formatieren.
+
  
−
<pre>
+
·
−
>>> txt1 = "My name is {fname}, I'm {age}".format(fname = "John", age = 36)
+
Folgen
−
>>> txt2 = "My name is {0}, I'm {1}".format("John",36)
+
−
>>> txt3 = "My name is {}, I'm {}".format("John",36)
+
−
>>> txt3 = "My name is {}, I'm {:5}".format("John",36)
+
−
>>> txt3
+
−
"My name is John, I'm    36"
+
−
>>> txt3 = "My name is {}, I'm {:5.2}".format("John",36)
+
−
>>> txt3
+
−
"My name is John, I'm    36"
+
−
>>> txt3 = "My name is {}, I'm {:5.2f}".format("John",36)
+
−
>>> txt3
+
−
"My name is John, I'm 36.00"
+
−
>>>
+
−
</pre>
+
−
== Slicing==
+
−
<pre>
+
−
The basics of slicing
+
  
−
My good friend John has a very long name:
+
Veröffentlicht in
 +
PythonFlood
  
−
John Alexander Harrington Fitzsimmons O'Leary Smith.
+
·
 +
5 Minuten gelesen
 +
·
 +
23. Mai
 +
43
  
−
Quite a mouthful, hun?!
 
  
−
Well, let's put these names into a list:
 
  
−
>>> 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]
+
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.
−
'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!)
+
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.
  
−
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-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.
  
−
By definition, “sequence slicing” is the means through which you can access multiple consecutive positions of a sequence, like a list.
+
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.
  
−
Here is an example to extract John's two first names:
+
Arten von Namespaces:
 +
In Python gibt es zwei Arten von Namespaces: Lokal und Global.
  
−
>>> names[0:2]
+
1. Lokaler Namespace:
−
['John', 'Alexander']
+
Ein lokaler Namespace wird bei jedem Aufruf einer Funktion erstellt und enthält alle Namen oder Bezeichner, die innerhalb dieser Funktion definiert sind.
  
−
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.
+
Auf den lokalen Namespace kann nur innerhalb der Funktion zugegriffen werden, und daran vorgenommene Änderungen werden außerhalb der Funktion nicht widergespiegelt.
  
−
The example above shows that the square brackets [], that you also use for indexing, are used for slicing.
+
Hier ist ein Beispiel eines von PythonFlood geschriebenen lokalen Namespace:
  
−
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:
+
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.
  
−
    start is the index of the first element to include in the result – names[0] is "John"
+
Sobald die Ausführung der Funktion abgeschlossen ist, wird der lokale Namespace zerstört.
−
    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.
+
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.
  
−
When the first integer of the slice is 0, it can be omitted.
+
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.
  
−
This means that names[0:2] and names[:2] is equivalent.
+
Hier ist ein Beispiel für einen globalen Namespace:
  
−
Similarly, if you want the slice to go all the way to the end of the sequence, you can omit the stop index.
+
x = 10
  
−
To give you an example of this, I'll tell you some inside information I got from a friend.
+
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.
  
−
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:
+
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.
  
−
def surnames(names):
+
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.
−
    return names[2:]
+
  
−
print(surnames(names))
+
Hier ist ein von PythonFlood geschriebenes Beispiel:
−
# ['Harrington', 'Fitzsimmons', "O'Leary", 'Smith']
+
  
−
Slices are objects, too!
+
Students = [ 'John' , 'Mary' , 'Bob' ]
  
−
I had been using slicing for a long time when I learned something crazy about slicing.
+
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.
  
−
Slices – the numbers you type separated by colons :, are actually Python objects!
+
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.
  
−
You can create a slice and use it to perform slicing operations:
+
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:
  
−
>>> names[slice(1, -1)]
+
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.
−
['Alexander', 'Harrington', 'Fitzsimmons', "O'Leary"]
+
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:
  
−
Isn't this surprising?!
+
x = 1
  
−
It blew my mind when I found out for the first time.
+
def  foo ():
 +
    x = 2
 +
    print ( "Inside foo:" , x)
  
−
But then again...
+
def  bar ():
 +
    global x
 +
    x = 3
 +
    print ( "Inside bar:" , x)
  
−
Everything in Python is an object, so maybe I shouldn't have been so surprised!
+
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.
  
−
Now, if slices are objects, then you can name them too!
+
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.
  
−
Here is a slice that drops the first element of any list:
+
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.
  
−
>>> drop_first = slice(1, None)
+
Best Practices für Namespace und Scope
−
>>> names[drop_first]
+
Hier sind einige Best Practices für die Verwendung von Namespaces und Bereichen in Ihrem Python-Code:
−
['Alexander', 'Harrington', 'Fitzsimmons', "O'Leary", 'Smith']
+
−
>>> ["first", "second", "third"][drop_first]
+
−
['second', 'third']
+
  
−
Take a moment to let that sink in!
+
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:
  
−
With named slices, you could rewrite the government code we saw above:
+
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.
  
−
>>> first_names = slice(None, 2)
+
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.
−
>>> surnames = slice(2, None)
+
−
>>> names[first_names]
+
−
['John', 'Alexander']
+
−
>>> names[surnames]
+
−
['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.
+
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.
  
−
However, I find that slicing is the perfect example of what “everything in Python is an object” means.
+
Insgesamt sind Namespaces und Bereiche wichtige Konzepte, die jeder Python-Programmierer verstehen muss, der hochwertigen, gut strukturierten Code schreiben möchte.
 +
</pre>
  
−
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!
+
== Navigation==
−
 
+
[[Micropython_Kurs_2023_-_Teil_1|Zurück zu Micropython Kurs 2023 - Teil 1]]<br>
−
Finally, I need to disclose that this email essentially copied the subject that my good friend Stephen wrote about very recently.
+
[[Micropython Kurs 2023|Zurück zur "Micropython Kurs 2023" Startseite]]<br>
−
 
+
[[Programmieren|Zurück zur Programmieren Startseite]]<br>
−
When I saw Stephen's email I jumped on my seat because I really like the fact that you can name slices.
+
[[Attraktor_Wiki|Zurück zur Wiki Startseite]]<br>
−
 
+
−
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>
+

Aktuelle Version vom 1. Oktober 2023, 17:05 Uhr

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

Von „https://wiki.attraktor.org/index.php?title=MPK23-Zwischenlager&oldid=38995“
Diese Seite wurde zuletzt am 1. Oktober 2023 um 17:05 Uhr geändert. Diese Seite wurde bisher 916 mal abgerufen.