La simulation de Pointeurs en Python

Je suis en train de faire de la compilation croisée dans la maison de la langue(dih) de Python.

L'un des dih caractéristiques est les pointeurs et les références qui se comportent comme vous vous attendez de C ou de C++.

Par exemple, vous pouvez faire ceci:

a = [1,2];  // a has an array 
b = &a;     // b points to a
*b = 2;     // derefernce b to store 2 in a
print(a);   // outputs 2
print(*b);   // outputs 2

Est-il un moyen de reproduire cette fonctionnalité en Python.

Je tiens à souligner que je crois que j'ai confondu un peu de gens. Je ne veux pas de pointeurs en Python. Je voulais juste avoir une idée de l'Python experts, ce Python je devrait générer pour simuler le cas, je l'ai montré ci-dessus

Mon Python n'est pas la plus grande, mais jusqu'à présent, mon exploration n'a pas abouti à quelque chose de prometteur:(

Je tiens à souligner que nous sommes à la recherche à passer de nos dih plus courante de la langue, donc nous ne sommes pas vraiment lié à Python si quelqu'un peut suggérer une autre langue qui peut être plus approprié.

Si vous essayez de compiler un assez faible niveau de langue à un assez haut niveau? Avez-vous envisagé d'autres plates-formes pour votre VM à la place?
cluecc.sourceforge.net compile C à divers niveau élevé de langues, mais qui n'ont pas un backend Python encore. Il serait intéressant de voir comment il se comporte, bien 🙂
Un problème avec votre exemple est que vous êtes en utilisant des entiers, ce qui en Python est immuable. I. e, vous ne pouvez pas les modifier. Ceci, combiné avec le fait que vous avez une variable de tableau, qui vous le remplacer par un entier dans votre code C (qui est horrible à partir d'un C, point de vue) signifie que vous êtes demandé un moyen de la mauvaise utilisation de Python dans une manière similaire à la façon dont vous l'abus C. Qui n'a tout simplement pas de sens.
Regbro. La langue que je veux en venir n'est-ce pas C. je pensais que j'avais fait clair pour vous maintenant:)
Utiliser la taille-1 listes pour mutable références et non-const pointeurs: a=[smth] b=[a] b[0][0] = 2 print a[0] print b[0][0]
Pourquoi ne pas b=a? Écrit b=[a] semble exagéré depuis a déjà est en fait un pointeur vers smth.

InformationsquelleAutor chollida | 2009-07-17

pointers python

78

Cela peut être fait de manière explicite.
```
class ref:
    def __init__(self, obj): self.obj = obj
    def get(self):    return self.obj
    def set(self, obj):      self.obj = obj

a = ref([1, 2])
b = a
print a.get()  # => [1, 2]
print b.get()  # => [1, 2]

b.set(2)
print a.get()  # => 2
print b.get()  # => 2
```
- Vous pourriez ne pas vouloir utiliser le nom de "ref", puisque c'est le même nom que le weakref de référence. Peut-être "ptr" ou quelque chose. Une mise en pratique sensible, si.
- Je pensais SML, lorsque cela est nécessaire 'a ref, mais oui, il serait préférable de choisir un plus nom unique. Pas sûr que ptr fait beaucoup de sens; il n'est en fait pas un pointeur, c'est plus comme un seul conteneur...
- Notez que ce n'est même significative lors de l'utilisation des objets immuables comme les entiers ou les chaînes de caractères. Pour mutable objets a=quelque Chose(); b=a; est parfaitement suffisant. Et même avec des objets immuables, il est assez inutile...
- Vous pouvez remplacer __call__ pour mettre en œuvre l'obtention et la configuration, ce qui est plus semblable à la façon dont un weakref se comporte.
- J'aime vraiment ça, et il est vraiment semblable à Python builtin propriété de la fonction. Vous pouvez également utiliser ctypes, voir ma réponse.
- Nice. L'ensemble du pointeur de l'histoire est en fait l'une des choses qui m'a permis d'aller à l'phyton. Comment ceux de cet aspect de la performance whise pour une primitive de type de données est - il pas beaucoup de frais généraux? la vôtre magu_
- Je ne pense pas que cela fonctionne de la manière qu'il a été prévu (comme d'autres l'ont souligné). Je suppose que le but ici est de garder un pointeur vers une autre variable, mais cette classe conserve la trace d'un objet n'est pas une variable. En raison de la façon dont la plupart Python (les noms des variables) de travail, qu'ils ne restent pas attachés à un même objet ou l'emplacement mémoire très longtemps. Donc, cette méthode serait bientôt perdre la trace. Par exemple. après une opération comme i = i + 1, i sera point à un nouvel objet.
- Il y a une bonne explication ici: stackoverflow.com/questions/986006/...
InformationsquelleAutor ephemient
20

Vous voudrez peut-être lire la Sémantique de Python, les noms de variables à partir d'un C++ perspective. La ligne du bas: Toutes les variables sont des références.

Plus au point, ne pas penser en termes de variables, mais en termes d'objets qui peuvent être nommé.
- Bien sûr, il a des variables: une variable en Python est un objet nommé. En disant "Python n'a pas de variables" est un peu déroutant inutilement les choses.
- Je prends variable pour signifier un "nom d'emplacement de mémoire'. Certes, cela peut ne pas être la bonne définition. Bien que cette phrase de Wikipedia, si j'interprète correctement, semble d'accord avec moi: en.wikipedia.org/wiki/Variable_%28programming%29#In_source_code
- Pas si vous êtes la pensée de variables fixes dans la mémoire de l'espace, qui est ce qu'il est en C.
- WP dit "un identificateur qui est lié à une valeur", ce qui je pense explique Python juste fine. (Le spécifique de la phrase que vous avez associé n'est pas en contradiction avec le présent: elle dit un nom de variable est une manière d'arriver à un emplacement de la mémoire, non pas que la localisation de la mémoire de la variable.) Si vous pensez que Python "n'ont pas de variables", puis la plupart des autres langages de programmation que j'ai utilisé n'est pas, non plus! 🙂
- Bon, j'ai changé le libellé. J'espère que c'est maintenant de moins en moins controversé 🙂
InformationsquelleAutor Stephan202
14

Si vous êtes à la compilation d'un C-comme la langue, de dire:
```
func()
{
    var a = 1;
    var *b = &a;
    *b = 2;
    assert(a == 2);
}
```
en Python, puis tous les "tout en Python est une référence" choses " est un abus de langage.

C'est vrai que tout en Python est une référence, mais le fait que de nombreux types de base (entiers, chaînes de caractères) sont immuables efficacement annule cette pour de nombreux cas. Il n'y a pas direct façon de mettre en œuvre le ci-dessus en Python.

Maintenant, vous pouvez le faire indirectement: pour toute immuable du type, de l'envelopper dans un mutable type. Ephemient la solution fonctionne, mais souvent, je viens de le faire:
```
a = [1]
b = a
b[0] = 2
assert a[0] == 2
```
(Je l'ai fait ce travail autour de Python est le manque de "non" dans le 2.x quelques fois.)

Cela implique beaucoup plus généraux: chaque immuable type (ou de chaque type, si vous n'essayez pas de les distinguer) soudain crée une liste (ou un autre objet conteneur), de sorte que vous êtes à l'augmentation de la surcharge pour les variables de manière significative. Individuellement, il n'est pas beaucoup, mais il va ajouter jusqu'à quand appliqué à l'ensemble de la base de code.

Vous pouvez réduire ce en seulement emballage immuable types, mais alors vous aurez besoin de garder une trace des variables de sortie sont enveloppés et qui ne le sont pas, de sorte que vous pouvez accéder à la valeur de "a" ou "a[0]" de manière appropriée. Il va probablement s'arracher les cheveux.

De savoir si c'est une bonne idée ou pas-qui dépend de pourquoi vous le faites. Si vous voulez juste quelque chose pour exécuter une machine virtuelle, j'aurais tendance à dire non. Si vous voulez être en mesure d'appeler à votre langue à partir de Python, je vous suggère de prendre votre VM existantes et la création de liaisons Python pour elle, de sorte que vous pouvez accéder et de les appeler à partir de Python.
- Ouais, mon ref est fondamentalement la dégénérée 1-l'élément seul cas de list. 1-tuple serait moindre frais généraux, mais, malheureusement, ceux qui ne sont pas mutables.
- Par la manière, je pense que ce que vous vraiment vous voulez est une cellule--c'est ce que Python utilise à des fermetures de magasins. Malheureusement, ceux-ci sont un détail d'implémentation qui ne sont pas exposés (on ne peut pas instancier directement.
InformationsquelleAutor Glenn Maynard

Presque exactement comme ephemient réponse, qui j'ai voté, vous pouvez utiliser Python builtin propriété fonction. Il va faire quelque chose près semblable à la ref classe dans ephemient réponse, sauf que maintenant, au lieu d'être forcé à utiliser get et set méthodes pour accéder à un ref exemple, vous venez d'appeler les attributs de votre instance à laquelle vous avez assigné comme propriétés dans la définition de classe. À partir de Python docs (sauf que j'ai changé C à ptr):

class ptr(object):
    def __init__(self):
        self._x = None
    def getx(self):
        return self._x
    def setx(self, value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

Les deux méthodes fonctionnent comme un C pointeur, sans avoir recours à global. Par exemple, si vous avez une fonction qui prend un pointeur:

def do_stuff_with_pointer(pointer, property, value):
    setattr(pointer, property, value)

Par exemple

a_ref = ptr()      # make pointer
a_ref.x = [1, 2]   # a_ref pointer has an array [1, 2]
b_ref = a_ref      # b_ref points to a_ref
# pass ``ptr`` instance to function that changes its content
do_stuff_with_pointer(b_ref, 'x', 3)
print a_ref.x      # outputs 3
print b_ref.x      # outputs 3

Un autre, et totalement fou option serait d'utiliser Python ctypes. Essayez ceci:

from ctypes import *
a = py_object([1,2]) # a has an array 
b = a                # b points to a
b.value = 2          # derefernce b to store 2 in a
print a.value        # outputs 2
print b.value        # outputs 2

ou si vous voulez vraiment faire de la fantaisie

from ctypes import *
a = py_object([1,2])   # a has an array 
b = pointer(a)         # b points to a
b.contents.value = 2   # derefernce b to store 2 in a
print a.value          # outputs 2
print b.contents.value # outputs 2

qui est plus proche de l'OP de la demande d'origine. fou!

InformationsquelleAutor Mark Mikofski

4

Comme d'autres ici l'ont dit, tous les Python variables sont essentiellement des pointeurs.

La clé pour comprendre le présent à partir d'un C point de vue est d'utiliser l'inconnu par beaucoup de fonction id (). Il vous indique ce que l'adresse de la variable de points.
```
>>> a = [1,2]
>>> id(a)
28354600

>>> b = a
>>> id(a)
28354600

>>> id(b)
28354600
```
- Le problème est de savoir comment déréférencement d'une telle adresse.
- c'est toujours très utile pour identifier les objets. sans cela, vous auriez besoin de hachage du contenu ou explicitement attribuer un id. en C, les pointeurs sont parfois utilisés pour distinguer les objets
- "Disponible détail de l'implémentation: C'est l'adresse de l'objet en mémoire." docs.python.org/2/library/functions.html#id
InformationsquelleAutor Unknown
3

Tout en Python est des pointeurs déjà, mais il est appelé "références" en Python. C'est la traduction de votre code Python:
```
a = [1,2]  // a has an array 
b = a     // b points to a
a = 2      // store 2 in a.
print(a)   // outputs 2
print(b)  // outputs [1,2]
```
"Déréférencement" n'a aucun sens, que c'est tous références. Il n'y a pas autre chose, donc, rien à déréférencer à.
- Merci pour la réponse. Qu'est-ce que mon sujet est la dernière ligne de votre réponse. Pour la sémantique correcte dans mon ancienne langue, j'avais besoin d'être à présent imprimer 2 comme dans l'ancienne langue, c'est un pointeur vers un.
- Ce n'est pas un pointeur alors, mais un alias, où vous pointez un nom à un autre nom. Vous ne pouvez pas le faire en Python, comme c'est complètement inutile. En Python, il vous suffit de l'appeler "a" tout le temps. Aucun alias nécessaire.
InformationsquelleAutor Lennart Regebro
1

C'est maladroit, mais une pensée...
```
# Change operations like:
b = &a

# To:
b = "a"

# And change operations like:
*b = 2

# To:
locals()[b] = 2


>>> a = [1,2]
>>> b = "a"
>>> locals()[b] = 2
>>> print(a)
2
>>> print(locals()[b])
2
```
Mais il n'y aurait pas de l'arithmétique des pointeurs ou tel, et ne sait pas quels sont les autres problèmes que vous pourriez rencontrer...
- Ce n'est probablement pas la meilleure idée, parce que les changements à la population locale() ne sont pas garantis pour être reflété dans l'environnement.
- Aussi, vous ne pouvez pas passer b dans d'autres fonctions de cette façon.
- Selon le commentaire de Paul - je l'ai testé dans une fonction, et il n'a même pas de changement de la variable y. Pouvez modifier les variables globales que dans une fonction, mais les habitants() apparemment est juste de donner une copie de la dict lorsque dans une fonction.
- Et encore: Pourquoi? Si vous voulez faire référence à un, il suffit d'utiliser un. C'est encore juste essayer de faire quelque chose qui est facile en Python, mais compliqué en C, le complexe C moyen.
- Je ne pense pas que quiconque ferait valoir ses la façon d'écrire du code Python. Mais il semble que ce que l'OP a été d'une simple mécaniste de convertir son code de travail Python. Et si c'est la priorité, alors peut-être trouver un moyen de la carte des pointeurs et de déréférencement sur Python pourrait atteindre cet objectif, il est vrai, à la coût de l'affreux - mais de travail - code Python.
InformationsquelleAutor Anon

class Pointer(object):
    def __init__(self, target=None):
        self.target = target

    _noarg = object()

    def __call__(self, target=_noarg):
        if target is not self._noarg:
            self.target = target
        return self.target

a = Pointer([1, 2])
b = a

print a() # => [1, 2]
print b() # => [1, 2]

b(2)
print a()  # => 2
print b()  # => 2

InformationsquelleAutor

Je pense que cet exemple est court et clair.

Ici, nous avons la classe avec implicite liste:

class A: 
   foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: [5]

En regardant ce profil de la mémoire (à l'aide de: from memory_profiler import profile), mon intuition me dit que cela peut en quelque sorte simuler des pointeurs comme dans C:

Filename: F:/MegaSync/Desktop/python_simulate_pointer_with_class.py
Line #    Mem usage    Increment   Line Contents
================================================
7     31.2 MiB      0.0 MiB   @profile
8                             def f():
9     31.2 MiB      0.0 MiB       a, b = A(), A()
10                                 #here memoery increase and is coupled
11     50.3 MiB     19.1 MiB       a.foo.append(np.arange(5000000))
12     73.2 MiB     22.9 MiB       b.foo.append(np.arange(6000000))
13     73.2 MiB      0.0 MiB       return a,b
[array([      0,       1,       2, ..., 4999997, 4999998, 4999999]), array([      0,       1,       2, ..., 5999997, 5999998, 5999999])] [array([      0,       1,       2, ..., 4999997, 4999998, 4999999]), array([      0,       1,       2, ..., 5999997, 5999998, 5999999])]
Filename: F:/MegaSync/Desktop/python_simulate_pointer_with_class.py
Line #    Mem usage    Increment   Line Contents
================================================
14     73.4 MiB      0.0 MiB   @profile
15                             def g():
16                                 #clearing b.foo list clears a.foo
17     31.5 MiB    -42.0 MiB       b.foo.clear()
18     31.5 MiB      0.0 MiB       return a,b
[] []
Filename: F:/MegaSync/Desktop/python_simulate_pointer_with_class.py
Line #    Mem usage    Increment   Line Contents
================================================
19     31.5 MiB      0.0 MiB   @profile
20                             def h():
21                                 #and here mem. coupling is lost ;/
22     69.6 MiB     38.1 MiB       b.foo=np.arange(10000000)
23                                 #memory inc. when b.foo is replaced
24    107.8 MiB     38.1 MiB       a.foo.append(np.arange(10000000))
25                                 #so its seams that modyfing items of
26                                 #existing object of variable a.foo,
27                                 #changes automaticcly items of b.foo
28                                 #and vice versa,but changing object
29                                 #a.foo itself splits with b.foo
30    107.8 MiB      0.0 MiB       return b,a
[array([      0,       1,       2, ..., 9999997, 9999998, 9999999])] [      0       1       2 ..., 9999997 9999998 9999999]

Et ici, nous avons explicite de soi dans la classe:

class A: 
def __init__(self): 
self.foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: []
Filename: F:/MegaSync/Desktop/python_simulate_pointer_with_class.py
Line #    Mem usage    Increment   Line Contents
================================================
44    107.8 MiB      0.0 MiB   @profile
45                             def f():
46    107.8 MiB      0.0 MiB       a, b = B(), B()
47                                 #here some memory increase
48                                 #and this mem. is not coupled
49    126.8 MiB     19.1 MiB       a.foo.append(np.arange(5000000))
50    149.7 MiB     22.9 MiB       b.foo.append(np.arange(6000000))
51    149.7 MiB      0.0 MiB       return a,b
[array([      0,       1,       2, ..., 5999997, 5999998, 5999999])] [array([      0,       1,       2, ..., 4999997, 4999998, 4999999])]
Filename: F:/MegaSync/Desktop/python_simulate_pointer_with_class.py
Line #    Mem usage    Increment   Line Contents
================================================
52    111.6 MiB      0.0 MiB   @profile
53                             def g():
54                                 #clearing b.foo list
55                                 #do not clear a.foo
56     92.5 MiB    -19.1 MiB       b.foo.clear()
57     92.5 MiB      0.0 MiB       return a,b
[] [array([      0,       1,       2, ..., 5999997, 5999998, 5999999])]
Filename: F:/MegaSync/Desktop/python_simulate_pointer_with_class.py
Line #    Mem usage    Increment   Line Contents
================================================
58     92.5 MiB      0.0 MiB   @profile
59                             def h():
60                                 #and here memory increse again ;/
61    107.8 MiB     15.3 MiB       b.foo=np.arange(10000000)
62                                 #memory inc. when b.foo is replaced
63    145.9 MiB     38.1 MiB       a.foo.append(np.arange(10000000))
64    145.9 MiB      0.0 MiB       return b,a
[array([      0,       1,       2, ..., 9999997, 9999998, 9999999])] [      0       1       2 ..., 9999997 9999998 9999999]

ps: je suis en auto-apprentissage de la programmation (commencé avec Python) donc merci de ne pas me détester si je me trompe. Son vient de la mine de l'intuition, que, permettez-moi de penser de cette façon, donc, ne me détestez pas!

InformationsquelleAutor

-2

Négatif, pas de pointeurs. Vous ne devez pas avec la manière dont le langage est conçu. Cependant, j'ai entendu une méchante rumeur que vous pourrait utiliser le: ctypes module à utiliser. Je ne l'ai pas utilisé, mais il sent salissant pour moi.
- Je sais qu'il n'y a pas de pointeurs en Python:) Mon but est de faire de la compilation croisée ma langue existante en Python donc je n'ai pas à l'appui d'une exécution plus longtemps. Ce Python aurais-je générer pour simuler mon exemple ci-dessus?
InformationsquelleAutor Alex

Vous devez vous connecter pour publier un commentaire.