面向对象两三事

实例和类的区别

1. 类:
   a. 变量: 所有实例共享
   b. 对象: 属性引用类.对象、实例化 对象=类()
   c. 绑定属性: 类中定义、运行时绑定

class Dog:
    kind = 'canine'    类中绑定 kind
Dog.country = 'China'   运行时绑定 country 

d. 属性引用: 数据属性、函数属性

2. 实例
   a. 变量: 每个实例独有
   b. 对象: 属性引用 对象.属性
   c. 绑定属性: 类中定义、运行时绑定

class Dog:

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

dog = Dog('Lily', 3)     类中的定义
dog.fur_color = 'red'    运行时修改

d. 属性引用:
1. 先到实例对象中查找属性再到类中查找
2. 属性绑定为实例对象创建新属性，属性存在时更新属性指向的对象

类的方法

类中有三种方法: 实例方法、静态方法、类方法

class Foo(object):
    """类三种方法语法形式"""
 
    def instance_method(self):
        print("是类{}的实例方法，只能被实例对象调用".format(Foo))
 
    @staticmethod
    def static_method():
        print("是静态方法")
 
    @classmethod
    def class_method(cls):
        print("是类方法")
 
foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print '----------------'
Foo.instance_method(foo) 类调用实例化方法,传参实例对象
Foo.static_method()
Foo.class_method()

结果:
  是类的实例方法，只能被实例对象调用
  是静态方法
  是类方法
  ----------------
  是类的实例方法，只能被实例对象调用
  是静态方法
  是类方法

实例方法，类方法(由@classmethod装饰的方法)，静态方法(由@staticmethod装饰的方法)都可以通过实例或者类调用，只不过实例方法通过类调用时需要传递实例的引用

1. 实例方法，第一个参数必须要默认传实例对象，一般习惯用self。
2. 静态方法，参数没有要求。
3. 类方法，第一个参数必须要默认传类，一般习惯用cls。

静态方法、类方法使用的区别或者使用场景

1. 定义多个构造函数

class Book(object):

    def __init__(self, title):
        self.title = title

    @classmethod
    def class_method_create(cls, title):
        book = cls(title=title)
        return book

    @staticmethod
    def static_method_create(title):
        book = Book(title)
        return book


book1 = Book("创建 init book 构造方法")
book2 = Book.class_method_create("创建 类方法 book 构造方法")
book3 = Book.static_method_create("创建 静态方法 book 构造方法")
print(book1.title)  # 创建 init book 构造方法
print(book2.title)  # 创建 类方法 book 构造方法
print(book3.title)  # 创建 静态方法 book 构造方法

2. 在静态方法中调用静态方法
3. 在类方法中调用静态方法

class Foo(object):
    X = 1
    Y = 2

    @staticmethod
    def averag(*mixes):
        # 先求和在除以元祖中的个数
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # 在静态方法中调用静态方法
        print("在静态方法中调用静态方法")
        return Foo.averag(Foo.X, Foo.Y)  # 通过类名调用averag

    @classmethod
    def class_method(cls):  # 在类方法中使用静态方法
        print("在类方法中使用静态方法")
        return cls.averag(cls.X, cls.Y)  # 通过cls 调用averag


foo = Foo()
print(foo.static_method())
print(foo.class_method())

4. 继承类中的区别

class Foo(object):
    X = 1
    Y = 14

    @staticmethod
    def averag(*mixes):  # "父类中的静态方法"
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # "父类中的静态方法"
        print("父类中的静态方法")
        print(Foo.X, Foo.Y)
        return Foo.averag(Foo.X, Foo.Y)  调用 Foo 的averag方法

    @classmethod
    def class_method(cls):  # 父类中的类方法
        print("父类中的类方法")
        return cls.averag(cls.X, cls.Y) #  cls 是调用他的类


class Son(Foo):
    X = 3
    Y = 5

    @staticmethod
    def averag(*mixes):  # "子类中重载了父类的静态方法"
        print("子类中重载了父类的静态方法")
        return sum(mixes) / 3


p = Son()
print(p.averag(1, 5))
print(p.static_method())    # 继承了父类的static_method静态方法，调用该方法，还是调用的父类的方法和类属性。
print(p.class_method())   # 继承了父类的class_method类方法，调用该方法，调用的是子类的方法和子类的类属性。