¿Punteros en Python?

Sé que Python no tiene punteros, pero ¿hay alguna manera de tener este rendimiento en su 2lugar?

>>> a = 1
>>> b = a # modify this line somehow so that b "points to" a
>>> a = 2
>>> b
1

?

He aquí un ejemplo: quiero form.data['field']y form.field.valuetener siempre el mismo valor. No es completamente necesario, pero creo que estaría bien.

En PHP, por ejemplo, puedo hacer esto:

<?php

class Form {
    public $data = [];
    public $fields;

    function __construct($fields) {
        $this->fields = $fields;
        foreach($this->fields as &$field) {
            $this->data[$field['id']] = &$field['value'];
        }
    }
}

$f = new Form([
    [
        'id' => 'fname',
        'value' => 'George'
    ],
    [
        'id' => 'lname',
        'value' => 'Lucas'
    ]
]);

echo $f->data['fname'], $f->fields[0]['value']; # George George
$f->data['fname'] = 'Ralph';
echo $f->data['fname'], $f->fields[0]['value']; # Ralph Ralph

Salida:

GeorgeGeorgeRalphRalph

ideone

O así en C ++ (creo que esto es correcto, pero mi C ++ está oxidado):

#include <iostream>
using namespace std;

int main() {
    int* a;
    int* b = a;
    *a = 1;
    cout << *a << endl << *b << endl; # 1 1

    return 0;
}

Quiero form.data['field']y form.field.valuetener siempre el mismo valor

Esto es factible, porque implica nombres decorados e indexación, es decir, construcciones completamente diferentes de las barenames a y sobre las bque estás preguntando, y porque con tu solicitud es completamente imposible. ¿Por qué pedir algo imposible y totalmente diferente de lo (posible) que realmente quieres ?

Tal vez no se dé cuenta de lo drásticamente diferentes que son las barenames y los nombres decorados. Cuando se refiere a un nombre desnudo a, obtiene exactamente el objeto al que ase vinculó por última vez en este alcance (o una excepción si no estaba vinculado en este alcance); este es un aspecto tan profundo y fundamental de Python que puede Posiblemente no sea subvertido. Cuando te refieres a un nombre decoradox.y , le estás pidiendo a un objeto (al que se xrefiere el objeto ) que proporcione "ely atributo", y en respuesta a esa solicitud, el objeto puede realizar cálculos totalmente arbitrarios (y la indexación es bastante similar: también permite realizar cálculos arbitrarios en respuesta).

Ahora, su ejemplo de "desiderata real" es misterioso porque en cada caso están involucrados dos niveles de indexación o obtención de atributos, por lo que la sutileza que anhela podría introducirse de muchas maneras. ¿Qué otros atributos se form.fieldsupone que tiene, por ejemplo, además value? Sin esos .valuecálculos adicionales , las posibilidades incluirían:

class Form(object):
   ...
   def __getattr__(self, name):
       return self.data[name]

y

class Form(object):
   ...
   @property
   def data(self):
       return self.__dict__

La presencia de .valuesugiere elegir la primera forma, además de una especie de envoltorio inútil:

class KouWrap(object):
   def __init__(self, value):
       self.value = value

class Form(object):
   ...
   def __getattr__(self, name):
       return KouWrap(self.data[name])

Si se supone que estas asignacionesform.field.value = 23 también establecen la entrada form.data, entonces el contenedor debe volverse más complejo, y no tan inútil:

class MciWrap(object):
   def __init__(self, data, k):
       self._data = data
       self._k = k
   @property
   def value(self):
       return self._data[self._k]
   @value.setter
   def value(self, v)
       self._data[self._k] = v

class Form(object):
   ...
   def __getattr__(self, name):
       return MciWrap(self.data, name)

El último ejemplo es más o menos lo más parecido, en Python, al sentido de "un puntero" que parece desear, pero es crucial comprender que tales sutilezas solo pueden funcionar con indexación y / o nombres decorados , nunca con barenames como pediste originalmente!

No hay forma de que puedas hacer eso cambiando solo esa línea. Tu puedes hacer:

a = [1]
b = a
a[0] = 2
b[0]

Eso crea una lista, asigna la referencia a a, luego b también, usa la referencia a para establecer el primer elemento en 2, luego accede usando la variable de referencia b.

No es un error, es una característica :-)

Cuando observe el operador '=' en Python, no piense en términos de asignación. No asignas cosas, las atas. = es un operador vinculante.

Entonces, en su código, le está dando al valor 1 un nombre: a. Entonces, le está dando al valor en 'a' un nombre: b. Entonces estás vinculando el valor 2 al nombre 'a'. El valor ligado a b no cambia en esta operación.

Viniendo de lenguajes similares a C, esto puede ser confuso, pero una vez que se acostumbre a él, encontrará que le ayuda a leer y razonar sobre su código más claramente: el valor que tiene el nombre 'b' no cambiará a menos que usted cambiarlo explícitamente. Y si hace una 'importación de esto', encontrará que el Zen de Python establece que Explícito es mejor que implícito.

Tenga en cuenta también que los lenguajes funcionales como Haskell también utilizan este paradigma, con un gran valor en términos de robustez.

¡Si! ¡Hay una forma de usar una variable como puntero en Python!

Lamento decir que muchas de las respuestas fueron parcialmente incorrectas. En principio, cada asignación igual (=) comparte la dirección de memoria (verifique la función id (obj)), pero en la práctica no es así. Hay variables cuyo comportamiento igual ("=") funciona en último término como una copia del espacio de memoria, principalmente en objetos simples (por ejemplo, objeto "int"), y otras en las que no (por ejemplo, objetos "lista", "dict") .

Aquí hay un ejemplo de asignación de puntero

dict1 = {'first':'hello', 'second':'world'}
dict2 = dict1 # pointer assignation mechanism
dict2['first'] = 'bye'
dict1
>>> {'first':'bye', 'second':'world'}

Aquí hay un ejemplo de asignación de copia

a = 1
b = a # copy of memory mechanism. up to here id(a) == id(b)
b = 2 # new address generation. therefore without pointer behaviour
a
>>> 1

La asignación de puntero es una herramienta bastante útil para crear un alias sin desperdiciar memoria extra, en ciertas situaciones para realizar un código cómodo,

class cls_X():
   ...
   def method_1():
      pd1 = self.obj_clsY.dict_vars_for_clsX['meth1'] # pointer dict 1: aliasing
      pd1['var4'] = self.method2(pd1['var1'], pd1['var2'], pd1['var3'])
   #enddef method_1
   ...
#endclass cls_X

pero hay que ser consciente de este uso para evitar errores de código.

Para concluir, por defecto algunas variables son barenames (objetos simples como int, float, str, ...), y algunas son punteros cuando se asignan entre ellas (por ejemplo, dict1 = dict2). ¿Cómo reconocerlos? prueba este experimento con ellos. En IDE con panel de explorador de variables, generalmente aparece la dirección de memoria ("@axbbbbbb ...") en la definición de objetos de mecanismo de puntero.

Sugiero investigar en el tema. Seguro que hay mucha gente que sabe mucho más sobre este tema. (ver módulo "ctypes"). Espero que sea útil. ¡Disfruta del buen uso de los objetos! Saludos, José Crespo

>> id(1)
1923344848  # identity of the location in memory where 1 is stored
>> id(1)
1923344848  # always the same
>> a = 1
>> b = a  # or equivalently b = 1, because 1 is immutable
>> id(a)
1923344848
>> id(b)  # equal to id(a)
1923344848

Como se puede ver a, y bson sólo dos nombres diferentes que hacen referencia a la misma objeto inmutable (int) 1. Si luego escribe a = 2, reasigna el nombre aa un objeto diferente (int) 2, pero la breferencia continúa a 1:

>> id(2)
1923344880
>> a = 2
>> id(a)
1923344880  # equal to id(2)
>> b
1           # b hasn't changed
>> id(b)
1923344848  # equal to id(1)

¿Qué pasaría si tuviera un objeto mutable en su lugar, como una lista [1]?

>> id([1])
328817608
>> id([1])
328664968  # different from the previous id, because each time a new list is created
>> a = [1]
>> id(a)
328817800
>> id(a)
328817800 # now same as before
>> b = a
>> id(b)
328817800  # same as id(a)

Nuevamente, estamos haciendo referencia al mismo objeto (lista) [1]con dos nombres diferentes ay b. Sin embargo ahora podemos mutar esta lista mientras que sigue siendo el mismo objeto, y a, ba los dos para continuar haciendo referencia a ella

>> a[0] = 2
>> a
[2]
>> b
[2]
>> id(a)
328817800  # same as before
>> id(b)
328817800  # same as before

Desde un punto de vista, todo es un puntero en Python. Su ejemplo funciona de manera muy similar al código C ++.

int* a = new int(1);
int* b = a;
a = new int(2);
cout << *b << endl;   // prints 1

(Un equivalente más cercano usaría algún tipo de en shared_ptr<Object>lugar de int*).

Aquí hay un ejemplo: quiero que form.data ['campo'] y form.field.value siempre tengan el mismo valor. No es completamente necesario, pero creo que estaría bien.

Puede hacer esto sobrecargando la clase de __getitem__in form.data.

Este es un puntero de Python (diferente de c / c ++)

>>> a = lambda : print('Hello')
>>> a
<function <lambda> at 0x0000018D192B9DC0>
>>> id(a) == int(0x0000018D192B9DC0)
True
>>> from ctypes import cast, py_object
>>> cast(id(a), py_object).value == cast(int(0x0000018D192B9DC0), py_object).value
True
>>> cast(id(a), py_object).value
<function <lambda> at 0x0000018D192B9DC0>
>>> cast(id(a), py_object).value()
Hello

Escribí la siguiente clase simple como, efectivamente, una forma de emular un puntero en Python:

class Parameter:
    """Syntactic sugar for getter/setter pair
    Usage:

    p = Parameter(getter, setter)

    Set parameter value:
    p(value)
    p.val = value
    p.set(value)

    Retrieve parameter value:
    p()
    p.val
    p.get()
    """
    def __init__(self, getter, setter):
        """Create parameter

        Required positional parameters:
        getter: called with no arguments, retrieves the parameter value.
        setter: called with value, sets the parameter.
        """
        self._get = getter
        self._set = setter

    def __call__(self, val=None):
        if val is not None:
            self._set(val)
        return self._get()

    def get(self):
        return self._get()

    def set(self, val):
        self._set(val)

    @property
    def val(self):
        return self._get()

    @val.setter
    def val(self, val):
        self._set(val)

Aquí hay un ejemplo de uso (de una página de cuaderno de jupyter):

l1 = list(range(10))
def l1_5_getter(lst=l1, number=5):
    return lst[number]

def l1_5_setter(val, lst=l1, number=5):
    lst[number] = val

[
    l1_5_getter(),
    l1_5_setter(12),
    l1,
    l1_5_getter()
]

Out = [5, None, [0, 1, 2, 3, 4, 12, 6, 7, 8, 9], 12]

p = Parameter(l1_5_getter, l1_5_setter)

print([
    p(),
    p.get(),
    p.val,
    p(13),
    p(),
    p.set(14),
    p.get()
])
p.val = 15
print(p.val, l1)

[12, 12, 12, 13, 13, None, 14]
15 [0, 1, 2, 3, 4, 15, 6, 7, 8, 9]

Por supuesto, también es fácil hacer que esto funcione para dict elementos o atributos de un objeto. Incluso hay una forma de hacer lo que pidió el OP, usando globals ():

def setter(val, dict=globals(), key='a'):
    dict[key] = val

def getter(dict=globals(), key='a'):
    return dict[key]

pa = Parameter(getter, setter)
pa(2)
print(a)
pa(3)
print(a)

Esto imprimirá 2, seguido de 3.

Jugar con el espacio de nombres global de esta manera es, de manera transparente, una idea terrible, pero muestra que es posible (si no es aconsejable) hacer lo que pidió el OP.

El ejemplo es, por supuesto, bastante inútil. Pero he encontrado que esta clase es útil en la aplicación para la que la desarrollé: un modelo matemático cuyo comportamiento se rige por numerosos parámetros matemáticos configurables por el usuario, de diversos tipos (que, debido a que dependen de argumentos de línea de comando, no se conocen en tiempo de compilación). Y una vez que el acceso a algo se ha encapsulado en un objeto de parámetro, todos esos objetos se pueden manipular de manera uniforme.

Aunque no se parece mucho a un puntero C o C ++, esto está resolviendo un problema que habría resuelto con punteros si estuviera escribiendo en C ++.

El siguiente código emula exactamente el comportamiento de los punteros en C:

from collections import deque # more efficient than list for appending things
pointer_storage = deque()
pointer_address = 0

class new:    
    def __init__(self):
        global pointer_storage    
        global pointer_address

        self.address = pointer_address
        self.val = None        
        pointer_storage.append(self)
        pointer_address += 1


def get_pointer(address):
    return pointer_storage[address]

def get_address(p):
    return p.address

null = new() # create a null pointer, whose address is 0    

A continuación se muestran ejemplos de uso:

p = new()
p.val = 'hello'
q = new()
q.val = p
r = new()
r.val = 33

p = get_pointer(3)
print(p.val, flush = True)
p.val = 43
print(get_pointer(3).val, flush = True)

Pero ahora es el momento de dar un código más profesional, incluida la opción de eliminar punteros, que acabo de encontrar en mi biblioteca personal:

# C pointer emulation:

from collections import deque # more efficient than list for appending things
from sortedcontainers import SortedList #perform add and discard in log(n) times


class new:      
    # C pointer emulation:
    # use as : p = new()
    #          p.val             
    #          p.val = something
    #          p.address
    #          get_address(p) 
    #          del_pointer(p) 
    #          null (a null pointer)

    __pointer_storage__ = SortedList(key = lambda p: p.address)
    __to_delete_pointers__ = deque()
    __pointer_address__ = 0 

    def __init__(self):      

        self.val = None 

        if new.__to_delete_pointers__:
            p = new.__to_delete_pointers__.pop()
            self.address = p.address
            new.__pointer_storage__.discard(p) # performed in log(n) time thanks to sortedcontainers
            new.__pointer_storage__.add(self)  # idem

        else:
            self.address = new.__pointer_address__
            new.__pointer_storage__.add(self)
            new.__pointer_address__ += 1


def get_pointer(address):
    return new.__pointer_storage__[address]


def get_address(p):
    return p.address


def del_pointer(p):
    new.__to_delete_pointers__.append(p)

null = new() # create a null pointer, whose address is 0