（绑定方法和非绑定方法）类方法，实例方法，静态方法 类属性和实例属性

1.总叔：

类方法 分为两大类三小类：

两大类：

绑定方法：

     类方法（classmethod）：  绑定给类去使用的方法  类去调用时，会默认把类本身和参数一起传给类方法

     实例方法（self）：绑定给实例去使用的方法     在类中定义一个函数，如果没绑定任何对象 def func（）   默认绑定给实例，调用的时候会默认传入self

非绑定方法：

    静态方法（@staticmethod）： 既没绑定给类也没绑定给实例    相当于一个普通的函数，类和方法都可以去调用

三小类： 类方法、实例方法、静态方法

  声明：一般绑定方法就用绑定的对象去调用   如果其它对象强制去调用，那么此时的绑定方法就会被当成普通的函数去使用

           如：类直接去调用实例方法def（self），就只是将绑定方法（实例方法），当作函数去用，有几个参数就要传入几个参数

2.类方法与实例方法 、静态方法

实例方法

    定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；

    调用：只能由实例对象调用。   如果类来调用只是当成一个普通的函数来使用

类方法

    定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；

    调用：实例对象和类对象都可以调用。

静态方法

    定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；

    调用：实例对象和类对象都可以调用

    静态方法实例

class Robot: 
    # __开头表示私有变量
    __counter = 0
    
    def __init__(self): 
        type(self).__counter += 1
   
    @staticmethod    
    def RobotInstances():
        return Robot.__counter
    
if __name__ == "__main__":
    x = Robot()
    # 下面可以访问
    print("通过实例访问: ", x.RobotInstances())
    # 下面可以访问
    print("通过类访问: ", Robot.RobotInstances())

 1.综合实例 

   类的作用  1.存储名称空间    2.用于创建实例    一般需要在类内部创建实例（把类作为参数去使用）的时候使用类方法   

                    2. 对象用就绑定实例方法，类用 就是绑定类方法    （把对象作为参数去使用）

                    编程的时候想着两种对象  一个对象  一个类   谁用绑定给谁    也要注意非绑定静态方法

  对象的作用  存储名称空间  包含属性和方法

import uuid
import settings


class MySQL:
    # 对象中有 host、port、id 三个属性
    def __init__(self, host, port):  # obj, '180.101.49.12', 443
        self.id = self.create_id()
        self.host = host
        self.port = port

    # 没绑定给实例（即没使用类的属性），也不需要绑定类（不需要使用cls去创建对象），所以将该方法变成 非绑定方法
    @staticmethod     
    def create_id():
        user_id = uuid.uuid4()
        return user_id

    # 3.从配置文件中获取host与port
    @classmethod
    def from_settings(cls):  # cls ---> MySQL类    类作为参数去使用
        obj = cls(settings.HOST, settings.PORT)  # ---> MySQL(settings.HOST, settings.PORT)    这里使用类在类内部创建对象
        return obj

    # 4.save和get_obj_by_id
    # 保存对象
    def save(self):

        import os
        import pickle

        db_path = settings.DB_PATH

        user_path = os.path.join(db_path, str(self.id))

        if not os.path.exists(user_path):
            with open(user_path, 'wb') as f:
                pickle.dump(self, f)
        else:
            # raise 异常类型('异常的打印信息'): 主动抛（触发）异常
            raise FileExistsError('对象文件已存在!')

    # 获取对象  根据id获取对象
    @staticmethod
    def get_obj_by_id(uu_id):  # 人为手动传入一个对象的id号
        import os
        import pickle

        db_path = settings.DB_PATH

        user_path = os.path.join(db_path, uu_id)

        with open(user_path, 'rb') as f:
            obj = pickle.load(f)
            return obj


# 调用类会，自动触发__init__，然后产生一个对象，将对象当做第一个参数传给__init__(self)
# 并将调用类括号中的参数一并传给__init__()
# 实例化方式一:
# obj = MySQL('180.101.49.12', 443)
# print(obj.id)
# print(obj.host)

# 实例化方式二:
# obj2 = MySQL(settings.HOST, settings.PORT)
# print(obj2.host)

# obj3 = MySQL.from_settings()
# print(obj3.host)
# print(type(uuid.uuid4()))


obj4 = MySQL(settings.HOST, settings.PORT)
obj4.save()
res = obj4.get_obj_by_id('2e241071-cd99-44e0-8aef-304b7d432d74')
print(res)

 调用实例

class C:

    def self_method(self, a):  # 建议用对象去调用，不建议用类去调用
        return a

    @classmethod
    def class_method(cls, a):  #建议用类去调用，不建议用对象去调用
        return a

    @staticmethod
    def static_method(a):    #  类和对象都可以调用
        return a

    def method(a):   #  这个方法只能由 类调用  
        return a

if __name__ == '__main__':
    c = C()
    # method
    #print(c.method('method'))   # 报错只有类能调用
    print(C.method('method'))
    
# 　　c = C()
# 　　print(c.self_method('self method'))
# 　　print(c.class_method('class method'))
# 　　print(c.static_method('static method'))
# 　　# print(c.method('method')) 运行出错
# 　　# print(C.self_method('self method')) 运行出错
# 　　print(C.class_method('class method'))
# 　　print(C.static_method('static method'))
# 　　print(C.method('method'))

3. 类属性 和 实例属性

# 类属性：可以通过 类和实例 来调用  查增改删
#  实例属性： 只能通过实例来访问