On 2024-08-10 20:09, Patrick Rudin <taxi...@gmx.ch> wrote:
> Der Begriff "Alias" verwirrt mich auch ein wenig. Wenn ich Aliasnamen
> benutze und mich als Klaus-Bärbel oder auch mal als Matrosentom ausgebe
> und mir jemand eine blutige Nase verpasst, dann zeigen beide Alias-Namen
> auf dieselbe Person, die eine blutige Nase hat. Passt nicht so ganz zum
> Informatik-Konzept.
Aliasing in Programmiersprachen bedeutet einfach, dass zwei Namen (oder
allgemeiner zwei Ausdrücke) das gleiche Ding bezeichnen, was auch immer
dieses Ding sein mag.
Dein Beispiel, in dem Du verschiedene Namen trägst, entspricht genau dem
Konzept von Python:
patrick_rudin = Person()
klaus_bärbel = patrick_rudin
matrosen_tom = patrick_rudin
# Hier haben wir jetzt eine Person mit drei Namen, nicht drei Klones.
matrosen_tom.kriegt_eine_auf_die_nase()
assert patrick_rudin.nase.blutet ()
;-)
Das ist auch insofern gleich, als im richtigen Leben ein Name nicht das
gleiche wie eine Person ist eine Person mehrere Namen haben kann, und
ein Name nicht einen anderen Namen bezeichnen kann, sondern nur eine
Person.
Es gibt natürlich auch Unterschiede, z.B. kann in Python ein Name immer
nur auf genau ein Objekt zeigen, während wir es im richtigen Leben
gewohnt sind, dass Namen nicht eindeutig sind und mehrere Personen
bezeichnen können.
Aber dieses Aliasing war offensichtlich nicht das, was Du gemeint hast.
Du meintest, dass das Ding, das da gealiast wird, der Ausdruck selbst
ist. Nach
b = t[1]
sollte
b = 10
exakt die gleichen Auswirkungen haben wie
t[1] = 10
Das passiert z.B. in Perl implizit in einer Schleife:
------------------------------------------------------------------------
#!/usr/bin/perl
use v5.30;
use warnings;
my @a = (1, 2, 3);
for my $x (@a) {
$x = 10;
}
say for @a;
------------------------------------------------------------------------
gibt
10
10
10
aus.
In C++ kann man das explizit mit Referenzen machen:
------------------------------------------------------------------------
#include <iostream> // 1
int main() { // 3
int a = 3; // 4
int &b = a; // 5
b = 5; // 6
std::cout << a << "\n"; // 7
return 0; // 8
} // 9
------------------------------------------------------------------------
Aber C++ unterscheidet sich von Python dadurch, dass Variablen ihre
Werte tatsächlich enthalten (und nicht nur auf sie verweisen). Im
Beispiel oben gibt es 4 Bytes am Stack, die der Compiler als "a"
bezeichnet und die zunächst mit dem Wert 0x00000003 überschrieben werden
(Zeile 4) und später mit dem Wert 0x00000005 (Zeile 6). b wiederum sind
8 Bytes, die mit der Adresse des ersten Bytes von a initialisiert werden
(Zeile 5) und weil der Compiler weiß, dass es eine Referenz ist, wird
bei der Zuweisung in Zeile 6 nicht b selbst (also die Adresse) geändert,
sondern das, worauf b zeigt.
In C müsste man das explizit machen:
------------------------------------------------------------------------
...
int *b = &a;
*b = 5;
...
------------------------------------------------------------------------
Hier ist b also kein Alias von a, sondern der Ausdruck *b (& bestimmt
die Adresse eines Objekts, * dereferenziert einen Pointer).
Die meisten Programmiersprachen, die ich kenne, folgen diesem "Eine
Variable ist ein Speicherbereich, der einen Wert enthält" Modell,
zumindest für einfache Typen. In Java sind Variablen vom Objekt-Typ
immer Referenzen. Wenn man von Java kommt, ist das Python-Modell daher
recht logisch: Da es in Python nur Objekt-Typen gibt (im Gegensatz zu
Java) verhalten sich alle Typen so wie die Objekt-Typen in Java.
hp
_______________________________________________
python-de Mailingliste -- python-de@python.org
Zur Abmeldung von dieser Mailingliste senden Sie eine Nachricht an
python-de-le...@python.org
https://mail.python.org/mailman3/lists/python-de.python.org/
Mitgliedsadresse: arch...@mail-archive.com
