绑定方法

# 绑定方法分为两种：
	1. 绑定给对象的  # 就是让对象来调用的
    2. 绑定给类的	# 就是让类来调用的
    
# 1. 绑定给对象的
class Student():
    school = ‘SH‘

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

    # 在类中书写方法，默认绑定给对象使用的
    def tell_info(self):
        print("%s-%s" % (self.name, self.age))

    def func(self):
        print("func")

obj = Student(‘egon‘, 18)
obj.tell_info()
obj.func()
    
# 2. 

import settings
class Mysql:
    school = ‘SH‘

    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    @classmethod # 意味着该方法绑定给类了，类来调用，会把类型当成第一个参数传过来
    def func(cls):
        # class_name => Mysql
        print(cls)
        return cls(settings.IP, settings.PORT)
        # return self.__class__(settings.IP, settings.PORT)
        # return Oracle(settings.IP, settings.PORT)

obj = Mysql(settings.IP, settings.PORT)

"""
总结：
    1. 绑定给对象的
        对象来调用，把对象自己当成第一个参数传递
    2. 绑定给类的方法
        @classmethod
        类来调用，把类名当成第一个参数传递
"""

非绑定方法

"""
非绑定方法：即不绑定给对象，也不绑定给类
"""

# import uuid
# print(uuid.uuid4())


class Test():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.id = self.create_id()

    @staticmethod  # 静态方法
    def create_id():
        import uuid
        return uuid.uuid4()


obj = Test(‘egon‘, 18)
print(obj.id)

# 用类调用
# print(Test.create_id())

# 用对象调用
print(obj.create_id())

如何隐藏属性

Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的），但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成“_类名__属性名”的形式：

class Foo:
    __N=0 # 变形为_Foo__N

    def __init__(self): # 定义函数时，会检测函数语法，所以__开头的属性也会变形
        self.__x=10 # 变形为self._Foo__x

    def __f1(self): # 变形为_Foo__f1
        print(‘__f1 run‘)

    def f2(self):  # 定义函数时，会检测函数语法，所以__开头的属性也会变形
        self.__f1() #变形为self._Foo__f1()

print(Foo.__N) # 报错AttributeError:类Foo没有属性__N

obj = Foo()
print(obbj.__x) # 报错AttributeError:对象obj没有属性__x

这种变形需要注意的问题是：

1、在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如Foo._A__N，所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。

>>> Foo.__dict__
mappingproxy({..., ‘_Foo__N‘: 0, ...})

>>> obj.__dict__
{‘_Foo__x‘: 10}

>>> Foo._Foo__N
0
>>> obj._Foo__x
10
>>> obj._Foo__N
0

2、在类内部是可以直接访问双下滑线开头的属性的，比如self.__f1()，因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。

>>> obj.f2()
__f1 run

3、变形操作只在类定义阶段发生一次,在类定义之后的赋值操作，不会变形。

>>> Foo.__M=100
>>> Foo.__dict__
mappingproxy({..., ‘__M‘: 100,...})
>>> Foo.__M
100

>>> obj.__y=20
>>> obj.__dict__
{‘__y‘: 20, ‘_Foo__x‘: 10}
>>> obj.__y
20

property装饰器

property装饰器： 就是将函数功能封装成数据属性

class Student():
    __school = ‘SH‘  # _Student__school
    __name = ‘egon‘
    def __init__(self, name):
        self.__name = name  # self._Student__name

    def __func(self):  # _Student__func
        print(‘func‘)

    # @property  # 这个函数已经变成了属性
    # def get_name(self):
    #     return self.__name  # self._Student__school
    @property  # 这个函数已经变成了属性
    def name(self):
        return self.__name  # self._Student__school

    @name.setter
    def name(self, v):
        self.__name = v

    @name.deleter
    def name(self):
        del self.__name

16.面向对象程序设计入门 ——02