python常用系统函数方法与模块
python基础语法总结（一）-- python类型转换函数+文件读写
python基础语法总结（二）-- 函数function
python基础语法总结（三）-- 数与字符串
python基础语法总结（四）-- list列表
python基础语法总结（五）-- 字典dic + 元组tuple
python基础语法总结（六）-- python类与OOP面向对象特性
目录
一. 类
1. 定义
2. 创建实例对象
3. 读写属性和调用方法
二. 继承
1. 继承语法
2. 多继承
3. 指定多继承下的继承源
三. 操作符重载
四. 静态方法、类方法、抽象方法
1. 静态方法
2. 类方法
3. 抽象方法
一. 类
1. 定义
### 定义类
class Animal: # 定义一个类animal
"""测试类Animal"""
color = "black" # 定义属性：颜色
age = 0 # 定义属性：年龄
name = "" # 定义姓名：name
def jump(self): # 定义类的方法，方法第一个入参必须是实例本身，可以不用字面量'self'表示，但本质仍然是实例本身为入参
print("can't jump")
def eat(self, food): # 有参数的方法
print("eat " + food)
def __healthy(self): # 私有方法
print("easy")
__habit = "think" # 定义私有变量， 以__双下划线开头的属性，为私有属性
def get_habit(self): # 读取私有属性
"""得到私有属性__habit的值"""
return self.__habit
def set_habit(self, habit): # 修改私有属性
"""设置私有属性__habit的值"""
self.__habit = habit
# 专有方法，以__开始，并且以__结束，有特殊的用途
def __init__(self, **args): #_init__()方法，在构造实例时，默认调用此方法创建出实例
"""专有方法__init__()"""
if args:
if 'name' in args.keys():
self.name = args['name']
if 'age' in args.keys():
self.age = args['age']
if 'color' in args.keys():
self.color = args['color']
2. 创建实例对象
### 创建类的实例
xh = Animal()
mm = Animal(color="Red", age=3) # 调用的时 __init__方法
3. 读写属性和调用方法
# 读取实例的公有属性
print(xh.color) # 访问color属性，得到默认值：black
print(mm.color) # 访问color属性，得到初始化的值Red
# 修改实例的公有属性
xh.name = '小黄' # 设置name属性为：小黄
print(xh.name) # 可以看到name属性确实改为：小黄
mm.age = 5
print(mm.age) # age改为5
# 私有属性在类的外部无法读取和修改，可以通过公有方法来读写
print(xh.__habit) # 报错：'Animal' object has no attribute '__habit'
print(xh.get_habit()) # 正确，得到私有属性的值：think
# 调用类的公有方法
xh.jump() # 第一个默认入参self不用写， 打印： can't jump
xh.eat("meat") # 调用有参数的方法，self同样不用写
二. 继承
1. 继承语法
### 继承
class Cat(Animal): # 继承父类animal，得到父类所有公有属性和公有方法
"""新建类Cat，继承自父类 Animal"""
def __init__(self):
super().__init__(color='white') # 调用父类的init方法，设置初始值color颜色为white
# print(__habit) 私有属性不能继承，这里会报错
mimi = Cat() # 新建对象mimi
print(mimi.color) # 颜色为white，默认值
2. 多继承
## python支持多继承
class A:
"""定义A父类"""
__a = 'A'
def show(self):
print(self.__a)
class B:
"""定义B父类"""
__b = "B"
def show(self):
print(self.__b)
class SubClass(A, B): # 多继承在括号内写入所有要继承的类，顺序--从左到右
"""定义SubClass类，继承A、B类"""
pass # 占位
sub = SubClass()
sub.show() # 因为顺序从左到右，所以show()方法继承自第一个有show()的父类：A
3. 指定多继承下的继承源
# 指定属性或方法的继承源
class SubClass(A,B): # 多继承在括号内写入所有要继承的类，顺序--从左到右
"""定义SubClass类，继承A、B类"""
show = B.show # 指定子类的show为父类B的show
sub = SubClass()
sub.show() # 因为指定B.show，所以子类的show()方法执行结果为：B
三. 操作符重载
### 操作符重载
class SpecalList:
"""操作符重载测试类"""
__list = []
def __init__(self, l):
self.__list = l
def __add__(self, other): # 重载__add__()操作符，使得SpecalList有特殊的 + 运算符实现
"""创建合并两个list的 + 操作符实现"""
result = self.__list
for item in other.getList():
result.append(item)
return SpecalList(result)
def getList(self):
return self.__list
# 调用实现
list1 = SpecalList([1,2,3])
list2 = SpecalList([8,7,6])
list3 = list1 + list2 # 通过操作符+， 实现调用__add__()方法
print(list3.getList()) # 可以看到结果为：[1, 2, 3, 8, 7, 6]
运算符与专有方法的对应关系
+ __add__()
- __sub__()
* __mul__()
/ __div__()
% __mod__()
** __pow__()
len() __len__()
四. 静态方法、类方法、抽象方法
可以参考文章：《Python 中的 classmethod 和 staticmethod 有什么具体用途？》
1. 静态方法
@staticmethod注解
class StaticClass:
"""静态方法"""
@staticmethod # 关键字
def treble_string(string): # 静态方法，不需要有self入参
return string * 3
StaticClass.treble_string("abc") # 直接调用，不用创建实例，本例：'abcabcabc'
2. 类方法
import math
class Pizza:
"""类方法"""
def __init__(self, radius, height):
self.radius = radius
self.height = height
@staticmethod
def compute_area(radius):
return math.pi * (radius ** 2)
@classmethod # 类方法的关键字
def compute_volume(cls, height, radius): # 类方法第一个参数是类本身
'''类方法与静态方法毕肖像，使用类方法主要是为了避免硬编码类名本身.
如果不使用类方法而改用静态方法@staticmethod，那么在调用本类其他方法和属性时，将不得不硬编码(本例需要写：Pizza.compute_area(),硬编码写了Pizza)
这样在Pizza类被继承后，compute_volume()这个方法可能会有问题，重写的方法和属性无效 '''
return height * cls.compute_area(radius)
def get_volume(self):
return self.compute_volume(self.height, self.radius)
# 调用类方法
Pizza.compute_volume(3,1) # 返回计算的体积9.42477796076938
3. 抽象方法
import abc
from abc import ABCMeta
class AbstractClass(metaclass=ABCMeta): # 引入抽象基础类
"""抽象类测试"""
def method1(self): # 设定method1()为抽象方法
""" python本身的语法没有抽象方法，子类可以直接重写此方法，来达到抽象方法的效果，这里定义一个空方法就可以
但是method1()这种方式有很大问题，如果程序员忘记重写，程序本身不会提示，这样不利于开发和调试"""
def method2(self):
""" 在要设定的抽象方法method2()中，方法体主动抛出异常
但这样也有小问题，只有在调用method2()时，才会报错，在编译阶段没有提醒"""
raise NotImplementedError
@abc.abstractmethod
def method3(self):
""" 引入@abc.abstractmethod，在开发(依赖IDE工具自身的检测)和编译阶段如果检查出子类没有重写此方法，则会报错"""
class SubClass(AbstractClass):
"""抽象类的子类，要重写父类抽象方法"""
def method1(self):
print("method1")
def method2(self):
print("method2")
def method3(self):
print("method3")
sc = SubClass() # 如果没有重写抽象类method3(),这里会报错
sc.method2()
sc.method3()