Pythonで明示的な「自己」を回避する方法は？

私はいくつかのpygameチュートリアルに従ってPythonを学んでいますます。

その中で、キーワードselfの広範な使用を発見し、主にJavaのバックグラウンドから来たため、selfと入力し忘れていることに気付きました。たとえば、rectは既にクラスのメンバー変数であるため、self.rect.centerx私はの代わりにを入力rect.centerxします。

Javaの平行な私は、この状況はとメンバ変数へのすべての参照を接頭辞に持つているためと考えることができ、この。

すべてのメンバー変数の先頭にselfを付けたままにしているのですか、それとも、そうしなくても済むようにそれらを宣言する方法はありますか？

私が提案しているものがpythonicではない場合でもで場合でも、それが可能かどうかを知りたいです。

私はこれらの関連するSOの質問を見ましたが、彼らは私が何を求めているかについては完全に答えていません：

• Python-クラスで「自己」を使用する理由
• Pythonメソッドに「自己」引数を明示的に指定する必要があるのはなぜですか？

Pythonではselfを指定する必要があります。 その結果、完全なクラス定義が表示されていなくても、メンバーと非メンバーを混同することはありません。これにより、次のような有用なプロパティが得られます。メンバー以外のメンバーを追加して、メンバー以外のメンバーを誤ってシャドウして、コードを破壊することはできません。

極端な例の1つ：クラスの基本クラスを知らなくてもクラスを作成でき、メンバーにアクセスしているかどうかを常に把握できます。

class A(some_function()):
  def f(self):
    self.member = 42
    self.method()

これが完全なコードです。（some_functionは、ベースとして使用されるタイプを返します。）

もう1つは、クラスのメソッドが動的に構成される場合です。

class B(object):
  pass

print B()
# <__main__.B object at 0xb7e4082c>

def B_init(self):
  self.answer = 42
def B_str(self):
  return "<The answer is %s.>" % self.answer
# notice these functions require no knowledge of the actual class
# how hard are they to read and realize that "members" are used?

B.__init__ = B_init
B.__str__ = B_str

print B()
# <The answer is 42.>

これらの例はどちらも極端なものであり、毎日目にすることはありません。また、このようなコードを頻繁に記述することはお勧めしませんが、明示的に要求される自己の側面を明確に示しています。

以前の回答はすべて基本的に「できない」または「すべきでない」の変形です。私は後者の意見に同意しますが、問題は技術的にまだ答えられていません。

さらに、実際の質問が尋ねていることに沿って誰かが何かをしたいと思う正当な理由があります。私が時々遭遇することの1つは、長い名前を使用すると式が認識できなくなる長い数学の方程式です。缶詰の例でこれを行う方法のいくつかの方法を次に示します。

import numpy as np
class MyFunkyGaussian() :
    def __init__(self, A, x0, w, s, y0) :
        self.A = float(A)
        self.x0 = x0
        self.w = w
        self.y0 = y0
        self.s = s

    # The correct way, but subjectively less readable to some (like me) 
    def calc1(self, x) :
        return (self.A/(self.w*np.sqrt(np.pi))/(1+self.s*self.w**2/2)
                * np.exp( -(x-self.x0)**2/self.w**2)
                * (1+self.s*(x-self.x0)**2) + self.y0 )

    # The correct way if you really don't want to use 'self' in the calculations
    def calc2(self, x) :
        # Explicity copy variables
        A, x0, w, y0, s = self.A, self.x0, self.w, self.y0, self.s
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

    # Probably a bad idea...
    def calc3(self, x) :
        # Automatically copy every class vairable
        for k in self.__dict__ : exec(k+'= self.'+k)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

g = MyFunkyGaussian(2.0, 1.5, 3.0, 5.0, 0.0)
print(g.calc1(0.5))
print(g.calc2(0.5))
print(g.calc3(0.5))

3番目の例-つまり、使用for k in self.__dict__ : exec(k+'= self.'+k)は基本的に質問が実際に求めているものですが、一般的には良い考えではないことを明確にさせてください。

詳細と、クラス変数または関数を反復処理する方法については、この質問に対する回答とディスカッションを参照してください。変数に動的に名前を付ける他の方法、およびこれが通常は良い考えではない理由については、このブログ投稿を参照してください。

更新： Python3の関数でローカルを動的に更新または変更する方法がないようです。そのため、calc3および類似のバリアントは使用できなくなりました。私が今考えることができる唯一のpython3互換のソリューションは使用することglobalsです：

def calc4(self, x) :
        # Automatically copy every class variable in globals
        globals().update(self.__dict__)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

これもまた、一般的にはひどい習慣です。

実際にselfはキーワードではありません。これは、Pythonのインスタンスメソッドの最初のパラメータに従来から付けられている名前です。そして、その最初のパラメーターは、メソッドが呼び出されているクラスのどのインスタンスを知るための唯一のメカニズムであるため、スキップできません。

たとえば、好きな名前を使用できます。

class test(object):
    def function(this, variable):
        this.variable = variable

あるいは

class test(object):
    def function(s, variable):
        s.variable = variable

しかし、スコープの名前を使用することに行き詰まっています。

あなたが説得力のある理由がない限り、私は自分とは違うものを使用することをお勧めしません。

はい、selfPythonの哲学によれば、明示的は暗黙的よりも優れているため、常にを指定する必要があります。

また、Pythonでのプログラミング方法は、Javaでのプログラミング方法とは大きく異なるため、 selfため、オブジェクト内にすべてを投影しないため減少する傾向があります。むしろ、より適切にテストできるモジュールレベルの関数をより多く使用します。

ところで。最初は嫌いでしたが、今は反対が嫌いです。インデント駆動のフロー制御についても同様です。

「自己」は、クラスの現在のオブジェクトインスタンスの従来のプレースホルダーです。「自分」を参照するかのように、クラスの内部でオブジェクトのプロパティ、フィールド、またはメソッドを参照する場合に使用します。しかし、Pythonプログラミングレルムの誰かが "self"を使い始めたのを短くするために、他のレルムは "this"を使用していますが、置換できないキーワードとして作成しています。私はコードを読みやすくするために「それ」を使用しました。これはPythonの優れた点の1つです。オブジェクトのインスタンスには、「自己」以外の独自のプレースホルダーを自由に選択できます。自己の例：

class UserAccount():    
    def __init__(self, user_type, username, password):
        self.user_type = user_type
        self.username = username            
        self.password = encrypt(password)        

    def get_password(self):
        return decrypt(self.password)

    def set_password(self, password):
        self.password = encrypt(password)

次に、「self」を「its」に置き換えます。

class UserAccount():    
    def __init__(its, user_type, username, password):
        its.user_type = user_type
        its.username = username            
        its.password = encrypt(password)        

    def get_password(its):
        return decrypt(its.password)

    def set_password(its, password):
        its.password = encrypt(password)

どちらがより読みやすくなりましたか？

selfはオブジェクトのメンバーにアクセスするためのpython構文の一部なので、あなたはそれで立ち往生していると思います

実際には、Armin Ronacherのプレゼンテーション「5年の悪いアイデア」からのレシピ「Implicit self」を使用できます（google it）。

アーミン・ロナッチャーのほとんどすべてのものと同じように、これは非常に賢いレシピですが、このアイデアは非常に魅力的だとは思いません。私はこれを明示的にしたいと思いますをC＃/ Javaでたます。

更新。「悪いアイデアのレシピ」へのリンク：https : //speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

ええ、自己は退屈です。しかし、それはより良いですか？

class Test:

    def __init__(_):
        _.test = 'test'

    def run(_):
        print _.test

From：Self Hell-よりステートフルな機能。

...ハイブリッドアプローチが最適です。実際に計算を行うすべてのクラスメソッドをクロージャーに移動し、構文をクリーンアップする拡張機能をクラスに保持する必要があります。クロージャをクラスに詰め込み、クラスを名前空間のように扱います。クロージャーは本質的に静的関数なので、クラスでもselfs *は必要ありません...

「グローバル」と同じように「メンバー」というステートメントがあると、クラスのオブジェクトメンバーであるインタープリターを認識できるので、より簡単で読みやすくなると思います。