Python面向对象 #2

一、绑定方法与非绑定方法

1. 绑定给对象的方法

首先我们要知道，凡是类中的方法或者是函数，都是默认都是绑定给对象使用的，下面我们代码实例来讲解绑定方法的应用。

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def info(self, username, password):
        print('name:%s, age:%s, gender:%s, username:%s, password:%s' % (self.name, self.age, self.gender, username, password))
		"""默认情况下，在类内部写方法是绑定给对象的，就有对象来调用，就会自动来传递参数"""

stu = Student('jack', 18, 'male')
print(stu.info)  # <bound method Student.info of <__main__.Student object at 0x000002D3FCFE5B80>>

从上面的输出结果来看，info()这个类中的方法，是绑定给对象使用的。下面，我在看看另外一种情况。

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def info():
        print('name:%s, age:%s, gender:%s, username:%s, password:%s' % (self.name, self.age, self.gender, username, password))
		"""默认情况下，在类内部写方法是绑定给对象的，就有对象来调用，就会自动来传递参数"""

stu = Student('jack', 18, 'male')
print(stu.info)  # <bound method Student.info of <__main__.Student object at 0x000002D3FCFE5B80>>

现在，我们将talk()函数的参数去掉，结果显示与上面是一样。这说明，不管是类中的方法，还是类中函数，默认情况下都是绑定给对象使用的。绑定给对象使用有一种好处，那就是不用手动将对象传入。对象是自动传到类中。如果你不信，我们来看看下面的例子：

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def info(self, username, password):
        print('name:%s, age:%s, gender:%s, username:%s, password:%s' % (
            self.name, self.age, self.gender, username, password))


stu = Student('jack', 18, 'male')
print(stu.info)  # <bound method Student.info of <__main__.Student object at 0x000002D3FCFE5B80>>  而对象来调用则为绑定方法
print(Student.info)  # <function Student.info at 0x0000017E4E222C10>  类来调用仅仅是当作函数使用

上面很好说明了，如果类来调用类中的方法，那么这个方法仅仅只是一个函数，那么既然是函数，就不会有自动传值这一功能。来看看下面代码：

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def info(self, username, password):
        print('name:%s, age:%s, gender:%s, username:%s, password:%s' % (
            self.name, self.age, self.gender, username, password))

stu = Student('jack', 18, 'male')

stu.info('jack', 123)  # 1
Student.info('jack', 123)  # 2

代码1正常输出结果为：
name:jack, age:18, gender:male, username:jack, password:123

代码2报错：
TypeError: info() missing 1 required positional argument: 'password'

从上面输出结果来看，当类调用类中的方法时候，是不会进行自动传值的，也就是说，函数有几个参数，我们就得传递进去几个参数。如果想结果正常运行，那么在类名调用talk()的时候，将参数一一都传递进去。即：

Student.info(stu, 'jack', 123)
# 必须把对象也传进去

而，当对象调用类中方法时候，则不用传递，如上面的2正常执行。既然知道了区别，那么，我们来看看下面代码：

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def info():
        pass


stu = Student('jack', 18, 'male')
stu.info()  # 1
Student.info()  # 2

代码1报错：
TypeError: info() takes 0 positional arguments but 1 was given

代码2正常

从输出结果来看，Student来调用info()方法时候，并不需要传递参数；而当对象来调用info()的时候，由于对象调用自己的绑定方法，会自动将对象当作第一个参数传递进去，所以，当类中()方法没有带参数时，而你又给它传递了一个，显然是会报错的。

综上所述，我们可以得出以下结论：

1.凡是类中的方法和函数，都是绑定给对象使用的；

2.绑定方法都有自动传值的功能。传递进去的值，就是对象本身。

3.如果类想调用绑定方法，就必须遵循函数的参数规则，有几个参数，就必须传递几个参数。

2. 类的绑定方法

既然类中的方法，默认都是绑定给对象使用，那么，我们要采取一点措施，将类中的绑定方法解除对象绑定关系，进而绑定到类上。

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


		"""
        此时该方法就是绑定给类的，那么就有类来调用，有什么特殊之处：就是会把类自动当成第一个参数传递给方法的第一个形参cls
        条件：
            1. 加一个装饰器@classmethod
            2. 把方法的第一个形参改为cls
            3. 外部调用该方法的时候使用类来调用即可
            4. 绑定给类的方法中没有self这个参数了
            5. 绑定给对象的方法中，就没有cls这个参数了
    	"""
    @classmethod
    def info(cls):
        return cls('jack', 18, 'male')


stu = Student('jack', 18, 'male')
print(Student.info)  # <bound method Student.info of <class '__main__.Student'>>

从上述结果可以看出，我们加上了一个装饰器，将类中绑定给对象的方法，绑定到类身上了。我们之前分析过，如果一个方法绑定到谁身上，那么在调用该函数的时候，将自动将该调用者当作第一个参数传递到函数中。但是，绑定到类的方法与绑定到对象方法有一点点不同：

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    @classmethod
    def info(cls):
        return cls('jack', 18, 'male')


stu = Student('jack', 18, 'male')
print(Student.info)  # <bound method Student.info of <class '__main__.Student'>>
print(stu.info)  # <bound method Student.info of <class '__main__.Student'>>

也就是说，当对象在调用类的绑定方法时，也会默认把类当作参数传递进去！所以下面执行正常，并不会因为这个方法绑定到类身上，而对象调用没有传递参数，报错！

在这里插入代码片class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    @classmethod
    def info(cls):
        return cls('jack', 18, 'male')


stu = Student()
Student.info()
stu.info()  # TypeError: __init__() missing 3 required positional arguments: 'name', 'age', and 'gender'

但是，如果talk()没有参数，则下面代码均会报错。

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    @classmethod
    def info():
        pass


stu = Student()  # TypeError: __init__() missing 3 required positional arguments: 'name', 'age', and 'gender'
Student.info()  # TypeError: info() takes 0 positional arguments but 1 was given
stu.info()

两者报错结果一致，这就说明了，当对象来调用类的绑定方法时，也是自动将类传递进去，并不需遵循函数参数传递的规则。

对于类中的绑定方法，也基本上就这两种，不管怎么变化，只要记住以下规则，遇到这种情况，都不会再错。

类中方法默认都是绑定给对象使用，当对象调用绑定方法时，会自动将对象作为第一个参数传递进去；而类来调用，则必须遵循函数参数一一对应的规则，有几个参数，就必须传递几个参数。如果一个方法是用了@classmethod装饰器，那么这个方法绑定到类身上，不管是对象来调用还是类调用，都会将类作为第一个参数传递进去。

类的绑定方法运用实例：单例模式！

二、非绑定方法（静态方法static）

上面说了，类中的方法要么是绑定给对象使用，要么是绑定给类使用，那么有没有不绑定给两者使用的函数？

答案：当然有，python给我们提供了@staticmethod，可以解除绑定关系，将一个类中的方法，变为一个普通函数。

下面，我们来看看代码示例：

class Student():
    school = '幼儿园'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    @staticmethod
    def info():
        print('hello world!')


stu = Student('jack', 20, 'male')
Student.info()  # hello world!
stu.info()  # hello world!

从上面的输出结果，我们可以看出，使用了@staticmethod装饰了一个函数，那么这个函数跟普通函数没有什么区别。既然是普通函数，那么就遵从函数参数传递规则，有几个参数就传递几个参数。

三、隐藏属性

1. 如何隐藏

class Student():
    __school = "XX"  # 加上下划线后就是隐藏了该属性，在类的外部不能访问
    """直接在属性名前面加上两个下划线__，就是隐藏该属性"""

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
	
	def __info(self):  # 加上下划线后就是隐藏了该方法，在类的外部不能访问
        print('from info')

	def index(self):
		return self.__school  # 对外不对内隐藏

stu = Student('jack', 18, 'male')

print(stu.school)  # 报错：AttributeError: 'Student' object has no attribute 'school'
print(stu._Student__school)  # 如果要访问就需要这样子来书写
stu._Student__info()  # 如果要访问就需要这样子来书写
print(stu.index())  #  可以直接调用对象函数并且执行结果

结合以上代码可以得出以下结论：

1.隐藏属性在定义阶段就发生了变形：_类名__属性名
2.可以隐藏属性、方法、对象都可以隐藏
3.对外不对内隐藏，对外部是隐藏的，而对内部是开放的

2.为何需要隐藏

class Student():
    __country = "XX"

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def get_index(self):  # 1.添加一个外部访问方法
        return self.__country

    def index(self, C):  # 2.添加一个修改方法，并添加一个形参，这个形参就是修改的内容
        if type(C) is not str:  # 这个时候我们可以做个判定：如果传过来的的参数不是字符串的话直接返回并打印“不能是数字”
            return print('不能是数字')
        Student.__country = C   # 3. 将传过来的实参赋予类属性


stu = Student('jack', 18, 'male')

stu.index(123)  # 不能是数字
stu.index('China')  # China
print(stu.get_index())  # China

结合以上代码可以得出以下结论：

由于隐藏属性是对外不对内，所以想要在类的外部使用，就需要在类的内部添加一个开放的接口，返回隐藏的属性值，以便更好的对外做限制

四、property装饰器

作用：把方法伪装成属性来使用！

class Student():
    __country = "XX"

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    @property  # 1.添加property装饰器
    def country(self):
        return self.__country

    @country.setter  # 修改属性
    def country(self, C):
        if type(C) is not str:
            return print('不能是数字')
        Student.__country = C

    @country.deleter  # 删除属性
    def country(self):
        del Student.__country


stu = Student('jack', 18, 'male')

stu.country = 'China'  # China
print(stu.country)  # China
del stu.country
print(Student.__dict__)

再添加一个属性也是如此

class Student():
    __country = "XX"
    __school = "SH"

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    @property  # 1.添加property装饰器
    def country(self):
        return self.__country

    @country.setter  # 修改属性
    def country(self, C):
        if type(C) is not str:
            return print('不能是数字')
        Student.__country = C

    @country.deleter  # 删除属性
    def country(self):
        del Student.__country


    @property  # 添加
    def school(self):
        return Student.__school

    @school.setter  # 修改
    def school(self, v):
        if type(v) is not str:
            return
        Student.__school = v

    @school.deleter  # 删除
    def school(self):
        del Student.__school


stu = Student('jack', 18, 'male')

stu.country = 'China'  # China
print(stu.country)  # China
del stu.country
print(Student.__dict__) # 查看类

stu.school = 'BJ'
print(stu.school)
del stu.school
print(Student.__dict__)