Python で自己を 1 つの記事で理解する

Magical self:

関数の最初のパラメータはインスタンスであることが Python クラスで規定されていますオブジェクトそのものであり、慣例により、その名前を self と書きます。その機能は Java のこれに相当し、現在のクラスのオブジェクトを表し、現在のクラスのプロパティとメソッドを呼び出すことができます。

クラスはオブジェクト指向の設計思想であり、クラスに基づいてインスタンス（つまりオブジェクト、オブジェクト）が作成されます。

クラス(クラス)にはデータとデータを操作するためのメソッドが含まれますが、一般的には属性と関数(つまりメソッドの呼び出し)です。

なぜクラス class で self を使用するのでしょうか?

クラス コード (関数) では、現在のインスタンスの変数と関数にアクセスする必要があります。つまり、インスタンス: インスタンス内の対応する変数 (プロパティ) にアクセスする必要があります。 .PropertyNam、前の値を読み取り、新しい値を書き込みます。

対応する関数 (関数) を呼び出します: Instance.function()、つまり、対応するアクションを実行します。

-> インスタンスの変数にアクセスしてインスタンスの関数を呼び出す必要がある場合は、当然のことながら、対応するインスタンスの Instance オブジェクト自体が必要です。

-> Python では、関数の最初のパラメータはインスタンス オブジェクト自体でなければならないと規定されており、慣例によりその名前を self と記述することが推奨されます。

-> したがって、self が必要です (self を使用する必要があります)。

まず、Python でのクラスの定義:

Python では、クラスはキーワード class:

に続いてクラスで定義されます。名前、つまり person は通常大文字で始まり、その後に (object) が続き、そのクラスがどのクラスから継承されているかを示します。通常、適切な継承クラスがない場合は、オブジェクト クラスが使用されます。これがすべての最後の単語です。すべてのクラスが継承されます。

class Person（object）:
    pass

パーソン クラスをインスタンス化します。インスタンス化はクラス名 () を使用して作成されます。

class Person(object):
    pass
student = Person()    # 创建类的实例化
print(student)
print(Person)

ご覧のとおり、変数 Student は Person オブジェクトを指しており、次の 0x0000026EE434D8D0 はメモリ アドレスです。各オブジェクトのアドレスは異なり、Person オブジェクトはそれ自体がクラスです。

属性をインスタンス変数にバインドすることもできます。たとえば、名前属性とスコア属性を Student にバインドします

class Person(object):
    pass
student = Person()
# print(student)
# print(Person)
student.name = "Gavin"     # 为实例变量 student 绑定 name 属性   类似于 赋值 操作
student.score = 100        # 为 其绑定  score 属性
print(student.name)
print(student.score)

ただし、上記のメソッドはインスタンスにすることもできます。クラスの変数バインディング属性は、あまり便利でエレガントではありません。クラスはテンプレートとして機能するため、インスタンスを作成するときに、バインドする必要があると思われる属性を強制的に埋めることができます。Python では、これは通常、クラスで使用されます。 def __init__(self) メソッドは、インスタンス変数の作成時に、名前やスコアなどの属性をインスタンス変数にバインドします。

class Person(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
        
student = Person('Gavin',100)    #  传入 __init__ 方法中需要的参数
print(student.name)
print(student.score)

空のパラメータが渡されると、エラーが報告されます:

class Person(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
        
student = Person()      # 此处应该有参数传入，却没有传
print(student.name)
print(student.score)

注:

1. __init__ メソッドの最初のパラメータは常に self であり、作成されたインスタンス自体を表します。したがって、self は作成されたインスタンス自体を指すため、__init__ メソッド内でさまざまな属性を self にバインドできます。

2. __init__ メソッドを使用する場合、インスタンスの作成時に空のパラメーターを渡すことはできません。__init__ メソッドに一致するパラメーターを渡す必要がありますが、self を渡す必要はありません。Python インタープリターが実行します。インスタンス変数を渡します。

関連する推奨事項: 「

Python ビデオ チュートリアル

」相互に呼び出すクラス内の複数の関数の定義

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
    def add(self):
        sum = self.x + self.y
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self):
        c = self.add()+self.square()
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可爱的分割线-----------')
print(student.add_square())

上記の例からわかるように、通常の関数と比較して、クラスで定義された関数の違いは次の 2 つだけです:

1. 最初のパラメーターは常に self であり、このパラメーターは次の場合に渡す必要はありません。

2. クラス内の関数が相互に呼び出す場合、上記の例のように self を追加する必要があります: c = self.add() self.square()、self が追加されていない場合は、エラーが報告されます: 関数は未定義です。下の図を参照してください:

除此之外，类的方法和普通函数没甚区别，当然也可以使用 默认参数、可变参数和关键字参数，例子如下：

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
        
    def add(self,z=16):         # 设置 默认变量 z =16,这只是个普通的局部变量，非实例变量，实例变量需要 
    self.z = z,这样定义
        sum = self.x + self.y + z
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self,z):        #  调用时传入变量，这也是个普通的局部变量，非实例变量 
        c = self.add()+self.square() + z
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可爱的分割线-----------')
print(student.add_square(16))

看了上述的例子可能还是不明白 self 到底是个什么鬼，为啥要使用 self 这鬼东西？没关系，往下看：

其实 self 这家伙简单的说就是把 class 中 定义的 变量和函数 变成 实例变量和实例函数，作为类 class 的成员，使得成员间能互相调用，而不需要从外部调用 数据（变量）和 方法（函数），以实现数据的封装，以上面的 Person 类为例：

创建实例的时候需要给出实例变量 x,y, 调用函数时给出 z ，调用很容易，却不知道内部实现的细节。

总之，类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都相互独立、互不影响；方法是与实例绑定的函数，和普通的函数不同，方法可以直接访问实例的数据。

其实 self 中存储的是实例变量和实例函数的属性，可以理解为一个字典（ dict ），如：{'name':'zhang','age':'18'}就是这些。

注意只有数据属性，并没有创建新的类的方法。  类----->通过实例化生成----对象---->（对象只是一串类似于字典的数据，没有把类的里的方法复制给你，python没有new这个方法！）

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
        
    def add(self,z=16):     # 设置 z 为实例变量，即 self.z = z, z 是 class 的一个成员了，而非普通局部变量
        self.z = z
        sum = self.x + self.y + z  # z虽然已被实例化，但是依然可以当作 普通变量来用
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self):        
        c = self.add()+self.square() + self.z  # 调用实例变量 z 
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可爱的分割线-----------')
print(student.add_square())
print(student.z)          # 函数add 中的 z 被实例化以后，就可以利用实例化的方法访问它

通过这个例子可以看出， z 本来是 add() 函数的默认形参，通过将其实例化，就可以在其他函数体内调用实例变量z 

被实例化以后，就可以利用实例化的方法访问它。

那么 self 到底是什么？

class Box(object):
    def __init__(self, boxname, size, color):
        self.boxname = boxname
        self.size = size
        self.color = color  # self就是用于存储对象属性的集合，就算没有属性self也是必备的
 
    def open(self, myself):
        print('-->用自己的myself，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类自己的self，打开那个%s,%s的%s' % (self.color, self.size, self.boxname))
 
    def close(self):
        print('-->关闭%s，谢谢' % self.boxname)
 
 
b = Box('魔盒', '14m', '红色')
b.close()
b.open(b)  # 本来就会自动传一个self，现在传入b，就会让open多得到一个实例对象本身，print看看是什么。
print(b.__dict__)  # 这里返回的就是self本身，self存储属性，没有动作。

self代表类的实例，而非类；self 就是 对象/实例 属性集合

Box 是个类-----》self 实例化------》 b对象/ 实例

class 抽象体------》实例化------》对象/实例，含有属性：{'boxname':'魔盒', ‘size’：‘14m’, 'color':'red'}，即 self

self 看似是整个对象，实际上清楚地描述了类就是产生对象的过程，描述了 self 就是得到了 对象，所以 self 内的键值可以直接使用

正如自然界中一个有效的对象，必须包括：

1、描述对象的属性；2、对象的方法

所以 self是必须的，也是对象中重要的特性。

看下面的代码，感觉就更神奇了：

class Box(object):
    def myInit(mySelf, boxname, size, color):
        mySelf.boxname = boxname
        mySelf.size = size
        mySelf.color = color  # 自己写一个初始化函数，一样奏效,甚至不用self命名。其它函数当中用标准self
        return mySelf  # 返回给实例化过程一个对象！神奇！并且含有对象属性/字典
 
    # def __init__(self, boxname, size, color):
    #     self.boxname = boxname
    #     self.size = size
    #     self.color = color  #注释掉原来标准的初始化
 
    def open(self, myself):
        print(self)
        print('-->用自己的myself，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类自己的self，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
 
    def close(self):
        print('-->关闭%s，谢谢' % self.boxname)
 
 
# 经过改造，运行结果和标准初始化没区别
 
b = Box().myInit('魔盒', '14m', '红色')
# b = Box('魔盒', '14m', '红色')#注释掉原来标准的初始化方法
b.close()
b.open(b)  # 本来就会自动传一个self，现在传入b，就会让open多得到一个实例对象本身，print看看是什么。
print(b.__dict__)  # 这里返回的就是self本身，self存储属性，没有动作。

换个角度来讲，对类的操作有：

1、定义属性 ； 2、调用方法

对类的反馈有：

1、得到属性 ； 2、执行方法

在 class 类的函数中，为什么 self是必要的，因为 self 是对象的载体，可以理解成一个字典，看下面代码：

class Box(object):
    def myInit(mySelf, boxname, size, color):
        print(mySelf.__dict__)#显示为{}空字典
        mySelf.boxname = boxname
        mySelf.__dict__['aa'] = 'w'#甚至可以像字典一样操作
        mySelf.size = size
        mySelf.color = color  # 自己写一个初始化函数，一样奏效,甚至不用self命名。其它函数当中用标准self
        return mySelf  # 返回给实例化过程一个对象！神奇！并且含有对象属性/字典
 
    # def __init__(self, boxname, size, color):
    #     self.boxname = boxname
    #     self.size = size
    #     self.color = color  #注释掉原来标准的初始化
 
    def open(self, myself):
        print(self)
        print('-->用自己的myself，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类自己的self，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
 
    def close(self):
        print('-->关闭%s，谢谢' % self.boxname)
 
 
# 经过改造，运行结果和标准初始化没区别
 
b = Box().myInit('魔盒', '14m', '红色')
# b = Box('魔盒', '14m', '红色')#注释掉原来标准的初始化方法
b.close()
b.open(b)  # 本来就会自动传一个self，现在传入b，就会让open多得到一个实例对象本身，print看看是什么。
print(b.__dict__)  # 这里返回的就是self本身，self存储属性，没有动作。

注意此处的： mySelf.__dict__['aa'] = 'w'  #甚至可以像字典一样操作； 在 b.__dict__ 的结果中显示为：'aa':'w'

故可以把 self 理解成存储 实例化对象属性的字典(dict), self 存储属性，而没有动作执行。

self总是指调用时的类的实例。

python 中一些特殊的实例变量：

1、私有变量(private),只有内部可以访问，外部不能访问，私有变量是在名称前以两个下划线开头，如：__name，其实私有变量也不是完全不能被外部访问，不能直接访问是因为python解释器对外把 __name 变量改成了 _类名__name,所仍然可以通过 _类名__name 来访问 __name。

2、在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。

3. _name などのアンダースコアで始まるインスタンス変数名は外部からアクセス可能ですが、規約上、このような変数を見た場合、「アクセスはできますが、よろしくお願いします」という意味になります。プライベート変数として保存し、自由にアクセスしないでください。」

以上がPython で自己を 1 つの記事で理解するの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。