đột biến/tại chỗ chức năng invokation hoặc thích ứng bằng Python

Question

tôi thường có báo cáo trong mã của tôi rằng làm như sau:

long_descriptive_variable_name = some_function(long_descriptive_variable_name) 

mà là rất rõ ràng, nhưng dài dòng và có phần dư thừa cùng một lúc. Có cách nào trong Python để đơn giản hóa tuyên bố này có lẽ bằng cách làm cho some_function hoạt động như một chức năng "đột biến" ("tại chỗ")?

Ví dụ, trong Julia one can often do sau:

some_function!(long_descriptive_variable_name) 

và điều này được cử đến các phiên bản của some_function rằng viết trực tiếp đến long_descriptive_variable_name, cập nhật một cách hiệu quả các biến.

Có cách nào để thể hiện chính xác giống nhau trong Python cho hàm chung some_function?

Điều gì sẽ làm tương tự với phương pháp đối tượng chung? ví dụ: simplifiying

long_variable_name = long_variable_name.method(arg1, arg2) 

Nếu ở trên không phải là (dễ dàng) doable với phiên bản hiện tại của Python, được có bất kỳ PEPs xem xét sự thay đổi này trong tương lai gần?

Answer 1

Những gì bạn đang yêu cầu có thể đạt được như vậy nhưng tôi chắc chắn sẽ không khuyên bạn nên làm việc đó:

>>> x = 10 
>>> def foo(func, string_of_var): 
    globals()[string_of_var] = func(globals()[string_of_var]) 

>>> def bar(x): 
    return x * 2 

>>> foo(bar, 'x') 
>>> x 
20 

Theo như một PEP để thay đổi nó nếu có một tôi nghi ngờ nó sẽ được chấp thuận . Gọi một hàm như thế này mà mặc nhiên thay đổi một giá trị đi ngược lại Zen của Python:

The Zen of Python, by Tim Peters 

Beautiful is better than ugly. 
Explicit is better than implicit. <==== Relevant line 
Simple is better than complex. 
Complex is better than complicated. 
Flat is better than nested. 
Sparse is better than dense. 
Readability counts. 
Special cases aren't special enough to break the rules. <==== also probably relevant 
Although practicality beats purity. 
Errors should never pass silently. 
Unless explicitly silenced. 
In the face of ambiguity, refuse the temptation to guess. 
There should be one-- and preferably only one --obvious way to do it. 
Although that way may not be obvious at first unless you're Dutch. 
Now is better than never. 
Although never is often better than *right* now. 
If the implementation is hard to explain, it's a bad idea. <==== And this one for good measure 
If the implementation is easy to explain, it may be a good idea. 
Namespaces are one honking great idea -- let's do more of those! 

này cũng có khả năng sẽ đòi hỏi một số tiền hợp lý của công việc mà không cần thêm nhiều đến ngôn ngữ. Python không có ++/-- cho this reason. Nó sẽ có nhiều công việc để thêm nó khi x += 1 đạt được điều tương tự. Điều tương tự cũng đúng ở đây, nó sẽ mất một số lượng không nhỏ của công việc của một số người để giúp bạn tiết kiệm một vài nét chính khi gọi chức năng.

Answer 2

TỪ BỎ: điều này không nên được sử dụng trong bất kỳ mã nào nghiêm trọng, tôi đã viết nó chỉ để vui và thậm chí không nghĩ rằng nó thông minh.

Không chắc chắn nếu đây là những gì bạn muốn (vì vậy tha thứ cho tôi nếu nó off-topic), nhưng tôi thực sự rất thích bản thân mình trong khi tạo ra điều này.

class FancyThing(object): 

    def __init__(self, value): 

     self.value = value 

    def update(self, callback): 

     self.value = callback(self.value) 

    def __get__(self, instance, owner): 

     return instance.value 

    def __set__(self, instance, value): 

     instance.value = value 

    def __str__(self): 

     return str(self.value) 

    def __add__(self, other): 

     return self.value + other 

Nếu bạn quấn thứ gì đó trong lớp này, bạn có thể update với bất kỳ gọi lại ngẫu nhiên nào.

def some_func(val): 
    return val * 3 

a = FancyThing(3.5) 
print a 

a.update(tester) 
print a 
b = a + 5 
print b 

Đầu ra:

3.5 
10.5 
15.5 

Phần buồn cười là bạn phải xác định nhiều các phương pháp tích hợp để có thể sử dụng giá trị nội bộ như một bình thường, giống như tôi đã làm cho __add__().