Ponteiros em Python?

Eu sei Python não tem ponteiros, mas existe uma maneira de ter esse rendimento 2em vez

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

?

Aqui está um exemplo: eu quero form.data['field']e form.field.valuesempre tenho o mesmo valor. Não é completamente necessário, mas acho que seria legal.

No PHP, por exemplo, eu posso fazer isso:

<?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

Resultado:

GeorgeGeorgeRalphRalph

ideona

Ou assim em C ++ (acho que está certo, mas meu C ++ está enferrujado):

#include <iostream>
using namespace std;

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

    return 0;
}

Quero form.data['field']e form.field.valuesempre ter o mesmo valor

Isso é possível, porque envolve nomes e indexação decorados - ou seja, construções completamente diferentes dos nomes de barras a e sobre as bquais você está perguntando, e com o seu pedido é totalmente impossível. Por que pedir algo impossível e totalmente diferente da (possível) coisa que você realmente quer ?!

Talvez você não perceba como nomes de barreiras e nomes decorados são drasticamente diferentes. Quando você se refere a um nome de barra a, está obtendo exatamente o aúltimo objeto vinculado a este escopo (ou uma exceção se não estiver vinculado a esse escopo) - esse é um aspecto tão profundo e fundamental do Python que pode possivelmente seja subvertido. Quando você se refere a um nome decoradox.y , solicita a um objeto (o objeto xse refere) que forneça "o yatributo" - e em resposta a essa solicitação, o objeto pode executar cálculos totalmente arbitrários (e a indexação é bastante semelhante: também permite que cálculos arbitrários sejam executados em resposta).

Agora, seu exemplo de "desiderata real" é misterioso porque, em cada caso, dois níveis de indexação ou obtenção de atributos estão envolvidos, portanto a sutileza que você deseja pode ser introduzida de várias maneiras. Que outros atributos form.fielddevem ter, por exemplo, além disso value? Sem esses .valuecálculos adicionais , as possibilidades incluiriam:

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

e

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

A presença de .valuesugestões para escolher a primeira forma, além de um tipo de invólucro inútil:

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

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

Se atribuições como form.field.value = 23também devem definir a entrada form.data, o wrapper deve se tornar realmente mais complexo e não tão 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)

O último exemplo é o mais aproximado possível, em Python, do sentido de "um ponteiro" como você deseja - mas é crucial entender que essas sutilezas podem funcionar apenas com indexação e / ou nomes decorados , nunca com nomes de barras como você pediu originalmente!

Não há como você fazer isso mudando apenas essa linha. Você pode fazer:

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

Isso cria uma lista, atribui a referência a e, em seguida, b também usa a referência a para definir o primeiro elemento para 2 e acessa usando a variável de referência b.

Isto não é um erro, é um recurso :-)

Quando você olha para o operador '=' no Python, não pense em termos de atribuição. Você não atribui coisas, vincula-as. = é um operador de ligação.

Portanto, no seu código, você está dando um nome ao valor 1: a. Então, você está dando o valor em 'a' a nome: b. Então você está vinculando o valor 2 ao nome 'a'. O valor vinculado a b não muda nesta operação.

Vindo de idiomas do tipo C, isso pode ser confuso, mas depois que você se acostuma, descobre que ajuda a ler e raciocinar sobre seu código com mais clareza: o valor que tem o nome 'b' não será alterado, a menos que você alterá-lo explicitamente. E se você 'importar isso', verá que o Zen do Python afirma que o Explícito é melhor do que implícito.

Observe também que linguagens funcionais como Haskell também usam esse paradigma, com grande valor em termos de robustez.

Sim! existe uma maneira de usar uma variável como um ponteiro em python!

Lamento dizer que muitas respostas estavam parcialmente erradas. Em princípio, toda atribuição igual (=) compartilha o endereço de memória (verifique a função id (obj)), mas, na prática, não é assim. Existem variáveis ​​cujo comportamento igual ("=") funciona no último termo como uma cópia do espaço da memória, principalmente em objetos simples (por exemplo, objeto "int") e outras em que não (por exemplo, objetos "list", "dict") .

Aqui está um exemplo de atribuição de ponteiro

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

Aqui está um exemplo de atribuição de cópia

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

A atribuição de ponteiro é uma ferramenta bastante útil para criar aliases sem o desperdício de memória extra, em certas situações para a execução de código confortável,

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

mas é preciso estar ciente desse uso para evitar erros de código.

Para concluir, por padrão, algumas variáveis ​​são nomes de barras (objetos simples como int, float, str, ...) e algumas são ponteiros quando atribuídas entre elas (por exemplo, dict1 = dict2). Como reconhecê-los? tente este experimento com eles. Nos IDEs com painel explorador variável, geralmente parece ser o endereço de memória ("@axbbbbbb ...") na definição de objetos de mecanismo de ponteiro.

Eu sugiro investigar no tópico. Há muitas pessoas que sabem muito mais sobre esse tópico com certeza. (consulte o módulo "ctypes"). Espero que seja útil. Aproveite o bom uso dos objetos! Atenciosamente, 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 você pode ver ae bsão apenas dois nomes diferentes que se referem ao mesmo objeto imutável (int) 1. Se você escrever mais tarde a = 2, redesigne o nome apara um objeto diferente (int) 2, mas a breferência continua 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)

O que aconteceria se você tivesse um objeto mutável, como uma 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)

Novamente, estamos nos referindo ao mesmo objeto (lista) [1]por dois nomes diferentes ae b. No entanto, agora podemos transformar esta lista enquanto ele permanece o mesmo objeto, e a, bambos continuarão fazendo referência a ele

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

De um ponto de vista, tudo é um ponteiro no Python. Seu exemplo funciona muito como o código C ++.

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

(Um equivalente mais próximo usaria algum tipo de em shared_ptr<Object>vez de int*.)

Aqui está um exemplo: Quero que form.data ['field'] e form.field.value tenham sempre o mesmo valor. Não é completamente necessário, mas acho que seria legal.

Você pode fazer isso por sobrecarga __getitem__na form.dataclasse 's.

Este é um ponteiro 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

Eu escrevi a seguinte classe simples como, efetivamente, uma maneira de emular um ponteiro em 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)

Aqui está um exemplo de uso (de uma página de caderno 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]

Obviamente, também é fácil fazer isso funcionar para itens de ditado ou atributos de um objeto. Existe até uma maneira de fazer o que o OP pediu, 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)

Isso imprimirá 2, seguidos por 3.

Mexer com o espaço para nome global dessa maneira é uma idéia terrível e transparente, mas mostra que é possível (se desaconselhável) fazer o que o OP solicitou.

O exemplo é, obviamente, bastante inútil. Mas achei essa classe útil no aplicativo para o qual a desenvolvi: um modelo matemático cujo comportamento é governado por vários parâmetros matemáticos configuráveis ​​pelo usuário, de diversos tipos (que, porque dependem de argumentos da linha de comando, não são conhecidos). em tempo de compilação). E uma vez que o acesso a algo tenha sido encapsulado em um objeto Parameter, todos esses objetos podem ser manipulados de maneira uniforme.

Embora não pareça muito com um ponteiro C ou C ++, isso está resolvendo um problema que eu teria resolvido com ponteiros se estivesse escrevendo em C ++.

O código a seguir emula exatamente o comportamento dos ponteiros em 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    

Aqui estão alguns exemplos 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)

Mas agora é hora de fornecer um código mais profissional, incluindo a opção de excluir ponteiros, que acabei de encontrar na minha biblioteca pessoal:

# 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