实例和类的区别
- 类:
a. 变量: 所有实例共享
b. 对象: 属性引用类.对象、实例化对象=类()
c. 绑定属性: 类中定义、运行时绑定
class Dog:
kind = 'canine' 类中绑定 kind
Dog.country = 'China' 运行时绑定 country
d. 属性引用: 数据属性、函数属性
- 实例
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()
结果:
是类<class '__main__.Foo'>的实例方法，只能被实例对象调用
是静态方法
是类方法
----------------
是类<class '__main__.Foo'>的实例方法，只能被实例对象调用
是静态方法
是类方法
实例方法，类方法(由@classmethod装饰的方法)，静态方法(由@staticmethod装饰的方法)都可以通过实例或者类调用，只不过实例方法通过类调用时需要传递实例的引用
- 实例方法，第一个参数必须要默认传实例对象，一般习惯用self。
- 静态方法，参数没有要求。
- 类方法，第一个参数必须要默认传类，一般习惯用cls。
静态方法、类方法使用的区别或者使用场景
- 定义多个构造函数
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 构造方法
- 在静态方法中调用静态方法
- 在类方法中调用静态方法
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())
- 继承类中的区别
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类方法，调用该方法，调用的是子类的方法和子类的类属性。
