『无为则无心』Python面向对象 — 47、Python中的self详解

目录

• 1、self的作用
• 2、self的使用注意事项
  • （1）self代表类的实例，而非类
  • （2）self不必非写成self，只是一种规范。
  • （3）类中方法的形参中一定要写self，包括内置函数
  • （4）__init__函数中，要把接收到的参数赋值到self中，提供全类使用
  • （5）同一个类中调用其他的方法时需要加self
  • （6）self总是指调用时的类的实例，在继承时中也一样
  • （7）self与私有变量的用法
  • （8）总结
  • （9）综合练习

1、self的作用

self指的是调用该函数的对象（是一个实例）。Python中self等价于Java中的this。

首先明确的是self只有在类中的方法中才会有，独立的函数或方法是不必带有self的。

例如：

# 定义方法
def showTime(name):
    print(f'大家好我是{name}，多多关照！')

# 调用方法
showTime('齐天大圣')

"""
输出结果：
大家好我是齐天大圣，多多关照！
"""

2、self的使用注意事项 （1）self代表类的实例，而非类

# self代表类的实例，而非类
class TestDemo():
    # 可将self理解为实例td
    def testFn(self):
        print(f"谁调用我,我就是谁,此时调用我的是{self}")
        # 实例调用__class__属性时会指向该实例对应的类
        print(f"我是按照{self.__class__}创建出来的")


# td为TestDemo的实例
td = TestDemo()
# 在类中方法的形参中，self参数一定要定义，但是在调用时会自动传入。
td.testFn()

执行结果如下：

谁调用我,我就是谁,此时调用我的是<__main__.TestDemo object at 0x00000000028836C8>
我是按照<class '__main__.TestDemo'>创建出来的

说明：

<__main__.TestDemo object at 0x00000000028836C8>表示:
self是一个TestDemo类型的object（对象），对象在内存的地址为0x00000000028836C8。

为什么self指的是类的实例对象，而不是类本身。

如果self指向类本身，那么当一个类有多个实例对象时，self指向哪一个呢？

（2）self不必非写成self，只是一种规范。

有很多人先学习别的语言，如Java，然后再学习Python的，所以总觉得self怪怪的，想写成this，可以吗？
当然可以，换成任何标识符都可以，把上面的代码改写一下。

# self代表类的实例，而非类
class TestDemo():
    # 可将self理解为实例td
    def testFn(this):
        print(f"谁调用我,我就是谁,此时调用我的是{this}")
        # 实例调用__class__属性时会指向该实例对应的类
        print(f"我是按照{this.__class__}创建出来的")


# td为TestDemo的实例
td = TestDemo()
# 在类中方法的形参中，self参数一定要定义，但是在调用时会自动传入。
td.testFn()

执行结果如下：

谁调用我,我就是谁,此时调用我的是<__main__.TestDemo object at 0x00000000028836C8>
我是按照<class '__main__.TestDemo'>创建出来的

改成this后，运行结果完全一样。
当然，最好还是尊重约定俗成的习惯，使用self。（不是最好，是一定。）

（3）类中方法的形参中一定要写self，包括内置函数

# 如果类中的方法不写self形参，
# 则不能使用对象.方法名()来调用方法，
# 只能使用类名.方法名()的方式来调用该方法，
# 类似与Java中的静态方法。

class TestDemo():
    # 定义一个方法，不定义self形参
    def testFn():
        print(f"不定义形参self，依旧可以调用我")
        print(__class__)

# 创建对象，用对象.方法名()来调用方法
td = TestDemo()
# 报错
# TypeError: testFn() takes 0 positional arguments but 1 was given
td.testFn()

# 只能使用类名.方法名()的方式来调用该方法。
TestDemo.testFn()

（4）__init__函数中，要把接收到的参数赋值到self中，提供全类使用

关于__init__函数，可以查看类的内置函数来了解。

class Student():
    def __init__(self, name, age, addr):
        # self的作用主要表示这个变量是类中的公共变量
        # 定义在self中的属性，整个类内都可以使用
        # 普通方法同理
        self.name = name
        self.age = age
        # 没有定义在self中的属性，只能在当前方法内使用
        addr = addr

    # 标准用法
    def tellMeName(self):
        # 如果去掉此处的self，会提示name 'name' is not defined
        print(f'我不叫孙悟空，我叫{self.name}')

    # 方法形参没有定义self，则报错
    # TypeError: tellMeAge() takes 0 positional arguments but 1 was given
    # def tellMeAge():
    def tellMeAge(self):
        # 如果获取age的值不加self，则获取不到，会报错
        # NameError: name 'age' is not defined
        # print(f'我今年{age}啦')
        print(f'我今年{self.age}啦')

    def tellMeAddr(self):
        # 因为__init__函数汇总没有把addr变量定义在self对象中
        # 所以addr变量的作用域只在__init__函数内，
        # 其他函数无法调用。
        # 添加在self对象内的属性为全局属性。
        print(f'我现居住在{self.addr}')


s = Student('美猴王', 18, addr='北京')
s.tellMeName()
s.tellMeAge()
s.tellMeAddr()

（5）同一个类中调用其他的方法时需要加self

class Student():
    def __init__(self, name, age, addr):
        # self的作用主要表示这个变量是类中的公共变量
        # 定义在self中的属性，整个类内都可以使用
        # 普通方法同理
        self.name = name
        self.age = age
        self.addr = addr


    def tellMeName(self):
        print(f'我不叫孙悟空，我叫{self.name}')

    def tellMeAge(self):
        print(f'我今年{self.age}啦')

    def tellMeAddr(self):
        print(f'我现居住在{self.addr}')

    def tellAll(self):
        # 如果调用类中的其他函数时，不用self调用，则会报错
        # NameError: name 'tellMeName' is not defined
        # tellMeName()
        self.tellMeName()
        self.tellMeAge()
        self.tellMeAddr()

s = Student('美猴王', 18, addr='北京')
s.tellAll()

"""
输出结果：
我不叫孙悟空，我叫美猴王
我今年18啦
我现居住在北京
"""

（6）self总是指调用时的类的实例，在继承时中也一样

# 定义一个父类
class Parent():
    def pFn(self):
        print(self)

# 定义一个子类
class Child(Parent):
    def cFn(self):
        print(self)

# 创建子类对象
child = Child()
# 调用子类方法
# <__main__.Child object at 0x00000000025A38C8>
child.cFn()
# 子类调用父类方法
# <__main__.Child object at 0x00000000025A38C8>
child.pFn()

# 创建父类
parent = Parent()
# 调用自己方法
# <__main__.Parent object at 0x00000000025A3908>
parent.pFn()

（7）self与私有变量的用法

# self的属性名称前加上两个下划线，就变成了一个私有变量（private）
# 只有类内部可以访问，外部不能直接访问
class Student():
    def setname(self, name1, name2):
        self.name1 = name1
        self.__name2 = name2

    def getname(self):
        print(f'我的第一个名字是{self.name1}，我的第二个名字是{self.__name2}')


stu = Student()
stu .setname("齐天大圣", "美猴王")
# 结果：我的第一个名字是齐天大圣，我的第二个名字是美猴王
stu .getname()

# 结果：齐天大圣
print(stu.name1)
# 结果报错：AttributeError: 'Student' object has no attribute 'name2'
# 说明私有变量并不能获取到
print(stu.name2)

（8）总结

• self总是指调用时的类的实例。
• self的名字并不是规定死的，但是在Python中self不是关键词，你可以定义成this、abc或其它名字都可以。但是约定成俗，减少代码理解难度。
• 在类中方法的形参中，self参数一定要定义，但是在调用时会自动传入。

（9）综合练习

一个类可以创建多个对象。

# 需求：洗衣机，功能：能洗衣服

# 1. 定义洗衣机类
class Washer():
    def wash(self):
        print('我会洗衣服')
        print(self)


# 2. 创建对象
haier1 = Washer()
# <__main__.Washer object at 0x0000000002553508>
print(haier1)
# haier1对象调用实例方法(对象方法)
haier1.wash()

# 3.创建第二个对象
haier2 = Washer()
# <__main__.Washer object at 0x0000000002553608>
print(haier2)
haier2.wash()
"""
输出结果：
<__main__.Washer object at 0x00000000025A3688>
我会洗衣服
<__main__.Washer object at 0x00000000025A3688>
<__main__.Washer object at 0x00000000025A3788>
我会洗衣服
<__main__.Washer object at 0x00000000025A3788>
"""


"""
可以看到每创建一个新的对象，都是有独立空间的对象，
所以每个对象的地址是不同的。
"""

注意：

可以看到每创建一个新的对象，都是有独立空间的对象，因为每个对象的地址是不同的。

每次打印对象和self得到的结果是一致的，说明self指向了对象的实例。