PYTHON面向对象编程基础知识
一、PYTHON面向对象编程前言
面向对象编程中,将函数和变量进一步封装成类,类才是程序的基本元素,它将数据和操作紧密地连结在一起,并保护数据不会被外界的函数意外地改变。类和和类的实例(也称对象)是面向对象的核心概念,是和面向过程编程、函数式编程的根本区别。
二、PYTHON面向对象编程基本概念
- 类(Class): 用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。其中的对象被称作类的实例。
- 实例:也称对象。通过类定义的初始化方法,赋予具体的值,成为一个”有血有肉的实体”。
- 实例化:创建类的实例的过程或操作。
- 实例变量:定义在实例中的变量,只作用于当前实例。
- 类变量:类变量是所有实例公有的变量。类变量定义在类中,但在方法体之外。
- 数据成员:类变量、实例变量、方法、类方法、静态方法和属性等的统称。
- 方法:类中定义的函数。
- 静态方法:不需要实例化就可以由类执行的方法
- 类方法:类方法是将类本身作为对象进行操作的方法。
- 方法重写(方法重载):如果从父类继承的方法不能满足子类的需求,可以对父类的方法进行改写,这个过程也称override。
- 封装:将内部实现包裹起来,对外透明,提供api接口进行调用的机制
- 继承:即一个派生类(derived class)继承父类(base class)的变量和方法。
- 多态:根据对象类型的不同以不同的方式进行处理。
三、调用类的三种方法
3.1实例方法
# -*- coding:utf8 -*-
class Student():
def __init__(self,name,gender):
self.name = name
self.gender = gender
def toprint(self):
print("my name is {0},and I am {1}".format(self.name,self.gender))
stu = Student("ZhangSan","Male")
#实例调用
stu.toprint()
运行结果:
3.2静态方法
静态方法由类调用,无默认参数。将实例方法参数中的self去掉,然后在方法定义上方加上@staticmethod,就成为静态方法。它属于类,和实例无关。建议只使用类名.静态方法的调用方式。(虽然也可以使用实例名.静态方法的方式调用)
经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法. 比如更改环境变量或者修改其他类的属性等能用到静态方法. 这种情况可以直接用函数解决, 但这样同样会扩散类内部的代码,造成维护困难。
# -*- coding:utf8 -*-
class Student():
@staticmethod
def toprint():
print("static method ...")
#静态方法调用
Student.toprint()
运行结果:
3.3类方法
类方法由类调用,采用@classmethod装饰,至少传入一个cls(代指类本身,类似self)参数。执行类方法时,自动将调用该方法的类赋值给cls。建议只使用类名.类方法的调用方式。(虽然也可以使用实例名.类方法的方式调用)
关于类方法的使用此处用以下例子来说明:
如下场景:
假设我有一个学生类和一个班级类,想要实现的功能为:
执行班级人数增加的操作、获得班级的总人数;
学生类继承自班级类,每实例化一个学生,班级人数都能增加;
最后,我想定义一些学生,获得班级中的总人数。
思考:这个问题用类方法做比较合适,为什么?因为我实例化的是学生,但是如果我从学生这一个实例中获得班级总人数,在逻辑上显然是不合理的。同时,如果想要获得班级总人数,如果生成一个班级的实例也是没有必要的。
代码如下:
# -*- coding:utf8 -*-
class StudentClass(object):
__num = 0
@classmethod
def addNum(cls):
cls.__num += 1
@classmethod
def getNum(cls):
return cls.__num
#__new__() 是一种负责创建类实例的静态方法,它无需使用 staticmethod 装饰器修饰,且该方法会优先 __init__() 初始化方法被调用。
#一般情况下,覆写 __new__() 的实现将会使用合适的参数调用其超类的 super().__new__(),并在返回之前修改实例。
def __new__(cls):
StudentClass.addNum()
return super(StudentClass, cls).__new__(cls)
class Student(StudentClass):
def __init__(self):
self.name = ""
a = Student()
b = Student()
c = Student()
print(StudentClass.getNum())
有关魔方函数new的使用请参考:Python new()方法详解
关于python中类方法请参考下列资料:
Python 中的 classmethod 和 staticmethod 有什么具体用途?
python类的三种方法
python中类方法,实例方法,静态方法的作用和区别
四、面向对象编程三要素
4.1封装
封装是指将数据与具体操作的实现代码放在某个对象内部,外部无法访问。必须要先调用类的方法才能启动。
4.2继承
当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)。
比如,我们已经编写了一个名为Animal的class,有一个run()方法可以直接打印:
继承有什么好处?最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法,因此,Dog和Cat作为它的子类,什么事也没干,就自动拥有了run()方法:
class Animal(object):
def run(self):
print("animal is running ... ")
class Dog(Animal):
pass
class Cat(Animal):
pass
dog = Dog()
cat = Cat()
dog.run()
cat.run()
当子类和父类都存在相同的run()方法时,我们说,子类的run()覆盖了父类的run(),在代码运行的时候,总是会调用子类的run()。这样,我们就获得了继承的另一个好处:多态。
4.3多态
要理解多态的好处,我们还需要再编写一个函数,这个函数接受一个Animal类型的变量:
# -*- coding:utf8 -*-
class Animal(object):
def run(self):
print("animal is running ... ")
class Dog(Animal):
def run(self):
print("dog is running ... ")
class Cat(Animal):
def run(self):
print("cat is running ... ")
def print_twice(animal):
animal.run()
animal.run()
dog = Dog()
cat = Cat()
print_twice(dog)
print_twice(cat)
新增一个Animal的子类,不必对run_twice()做任何修改,实际上,任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行,原因就在于多态。
多态的好处就是,当我们需要传入Dog、Cat、Tortoise……时,我们只需要接收Animal类型就可以了,因为Dog、Cat、Tortoise……都是Animal类型,然后,按照Animal类型进行操作即可。由于Animal类型有run()方法,因此,传入的任意类型,只要是Animal类或者子类,就会自动调用实际类型的run()方法,这就是多态的意思:
对于一个变量,我们只需要知道它是Animal类型,无需确切地知道它的子类型,就可以放心地调用run()方法,而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上,由运行时该对象的确切类型决定,这就是多态真正的威力:调用方只管调用,不管细节,而当我们新增一种Animal的子类时,只要确保run()方法编写正确,不用管原来的代码是如何调用的。这就是著名的“开闭”原则:
对扩展开放:允许新增Animal子类;
对修改封闭:不需要修改依赖Animal类型的run_twice()等函数。
总结:继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写;
有了继承,才能有多态。在调用类实例方法的时候,尽量把变量视作父类类型,这样,所有子类类型都可以正常被接收;
旧的方式定义Python类允许不从object类继承,但这种编程方式已经严重不推荐使用。任何时候,如果没有合适的类可以继承,就继承自object类。
五、魔法函数
__init__ : 构造函数,在生成对象时调用
__del__ : 析构函数,释放对象时使用
__repr__ : 打印,转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 幂
具体使用
- doc
说明性文档和信息。Python自建,无需自定义。
class Foo:
""" 描述类信息,可被自动收集 """
def func(self):
pass
# 打印类的说明文档
print(Foo.__doc__)
- init()
实例化方法,通过类创建实例时,自动触发执行。
class Foo:
def __init__(self, name):
self.name = name
self.age = 18
obj = Foo(jack') # 自动执行类中的 __init__ 方法
- module__ 和 __class
module 表示当前操作的对象在属于哪个模块。
class 表示当前操作的对象属于哪个类。
这两者也是Python内建,无需自定义。
class Foo:
pass
obj = Foo()
print(obj.__module__)
print(obj.__class__)
运行结果:
main
4. del()
析构方法,当对象在内存中被释放时,自动触发此方法。
注:此方法一般无须自定义,因为Python自带内存分配和释放机制,除非你需要在释放的时候指定做一些动作。析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:
def __del__(self):
print("我被回收了!")
obj = Foo()
del obj
- call()
如果为一个类编写了该方法,那么在该类的实例后面加括号,可会调用这个方法。
注:构造方法的执行是由类加括号执行的,即:对象 = 类名(),而对于call() 方法,是由对象后加括号触发的,即:对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
#可以用Python内建的callable()函数进行测试,判断一个对象是否可以被执行。
callable(Student())
运行结果:
True
6. dict
列出类或对象中的所有成员!非常重要和有用的一个属性,Python自建,无需用户自己定义。
class Province:
country = 'China'
def __init__(self, name, count):
self.name = name
self.count = count
def func(self, *args, **kwargs):
print('func')
# 获取类的成员
print(Province.__dict__)
# 获取 对象obj1 的成员
obj1 = Province('HeBei',10000)
print(obj1.__dict__)
# 获取 对象obj2 的成员
obj2 = Province('HeNan', 3888)
print(obj2.__dict__)
- str()
如果一个类中定义了str()方法,那么在打印对象时,默认输出该方法的返回值。这也是一个非常重要的方法,需要用户自己定义。
下面的类,没有定义str()方法,打印结果是:
class Foo:
pass
obj = Foo()
print(obj)
定义了__str__()方法后,打印结果是:'jack'。
class Foo:
def __str__(self):
return 'jack'
obj = Foo()
print(obj)
8、getitem__()、setitem()、__delitem()
取值、赋值、删除这“三剑客”的套路,在Python中,我们已经见过很多次了,比如前面的@property装饰器。
Python中,标识符后面加圆括号,通常代表执行或调用方法的意思。而在标识符后面加中括号[],通常代表取值的意思。Python设计了getitem()、setitem()、delitem()这三个特殊成员,用于执行与中括号有关的动作。它们分别表示取值、赋值、删除数据。
也就是如下的操作:
a = 标识符[] : 执行__getitem__方法
标识符[] = a : 执行__setitem__方法
del 标识符[] : 执行__delitem__方法
如果有一个类同时定义了这三个魔法方法,那么这个类的实例的行为看起来就像一个字典一样,如下例所示:
class Foo:
def __getitem__(self, key):
print('__getitem__',key)
def __setitem__(self, key, value):
print('__setitem__',key,value)
def __delitem__(self, key):
print('__delitem__',key)
obj = Foo()
result = obj['k1'] # 自动触发执行 __getitem__
obj['k2'] = 'jack' # 自动触发执行 __setitem__
del obj['k1'] # 自动触发执行 __delitem__
- iter()
这是迭代器方法!列表、字典、元组之所以可以进行for循环,是因为其内部定义了 iter()这个方法。如果用户想让自定义的类的对象可以被迭代,那么就需要在类中定义这个方法,并且让该方法的返回值是一个可迭代的对象。当在代码中利用for循环遍历对象时,就会调用类的这个iter()方法。
普通的类:
class Foo:
pass
obj = Foo()
for i in obj:
print(i)
# 报错:TypeError: 'Foo' object is not iterable<br># 原因是Foo对象不可迭代
#添加一个__iter__(),但什么都不返回:
class Foo:
def __iter__(self):
pass
obj = Foo()
for i in obj:
print(i)
# 报错:TypeError: iter() returned non-iterator of type 'NoneType'
#原因是 __iter__方法没有返回一个可迭代的对象
#返回一个个迭代对象:
class Foo:
def __init__(self, sq):
self.sq = sq
def __iter__(self):
return iter(self.sq)
obj = Foo([11,22,33,44])
for i in obj:
print(i)
#最好的方法是使用生成器:
class Foo:
def __init__(self):
pass
def __iter__(self):
yield 1
yield 2
yield 3
obj = Foo()
for i in obj:
print(i)
10、len()
在Python中,如果你调用内置的len()函数试图获取一个对象的长度,在后台,其实是去调用该对象的len()方法,所以,下面的代码是等价的:
len('ABC')
3
'ABC'.__len__()
3
Python的list、dict、str等内置数据类型都实现了该方法,但是你自定义的类要实现len方法需要好好设计。
- repr()
这个方法的作用和str()很像,两者的区别是str()返回用户看到的字符串,而repr()返回程序开发者看到的字符串,也就是说,repr()是为调试服务的。通常两者代码一样。
class Foo:
def __init__(self, name):
self.name = name
def __str__(self):
return "this is %s" % self.name
__repr__ = __str__
- add__: 加运算 sub: 减运算 mul: 乘运算 div: 除运算 mod: 求余运算 __pow: 幂运算
这些都是算术运算方法,需要你自己为类设计具体运算代码。有些Python内置数据类型,比如int就带有这些方法。Python支持运算符的重载,也就是重写。
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
- author作者信息
__author__ = "Jack"
def show():
print(__author__)
show()
- slots
Python作为一种动态语言,可以在类定义完成和实例化后,给类或者对象继续添加随意个数或者任意类型的变量或方法,这是动态语言的特性。例如:
def print_doc(self):
print("haha")
class Foo:
pass
obj1 = Foo()
obj2 = Foo()
# 动态添加实例变量
obj1.name = "jack"
obj2.age = 18
# 动态的给类添加实例方法
Foo.show = print_doc
obj1.show()
obj2.show()
但是!如果我想限制实例可以添加的变量怎么办?可以使slots限制实例的变量,比如,只允许Foo的实例添加name和age属性。
def print_doc(self):
print("haha")
class Foo:
__slots__ = ("name", "age")
pass
obj1 = Foo()
obj2 = Foo()
# 动态添加实例变量
obj1.name = "jack"
obj2.age = 18
obj1.sex = "male" # 这一句会弹出错误
# 但是无法限制给类添加方法
Foo.show = print_doc
obj1.show()
obj2.show()
#由于'sex'不在__slots__的列表中,所以不能绑定sex属性,试图绑定sex将得到AttributeError的错误。
Traceback (most recent call last):
File "F:/Python/pycharm/201705/1.py", line 14, in <module>
obj1.sex = "male"
AttributeError: 'Foo' object has no attribute 'sex'
需要提醒的是,slots定义的属性仅对当前类的实例起作用,对继承了它的子类是不起作用的。想想也是这个道理,如果你继承一个父类,却莫名其妙发现有些变量无法定义,那不是大问题么?如果非要子类也被限制,除非在子类中也定义slots,这样,子类实例允许定义的属性就是自身的slots加上父类的slots。
六、成员保护与访问机制
参考这篇文章:https://www.liaoxuefeng.com/wiki/1016959663602400/1017496679217440
参考资料
1.面向对象编程(https://www.liaoxuefeng.com/wiki/1016959663602400/1017495723838528)
2.史上最全 Python 面向对象编程(https://zhuanlan.zhihu.com/p/61042358)