|
一、Python创建类
使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾：
class ClassName:
'类的帮助信息' #类文档字符串
class_suite #类体
class_suite 由类成员，方法，数据属性组成
以下是一个简单的 Python 类的例子
class Employee:
'雇员类'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print ("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print ("Name : ", self.name, ", Salary: ", self.salary)
empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用Employee.empCount 访问。
第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数
self代表类的实例，而非类。Python类的方法与普通方法只有一个特别的区别：就是类的方法必须有一个额外的第一个参数名称，按照惯例它的名称是self。
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
以上实例执行结果为：
<__main__.Test object at 0x0000028274977670>
<class '__main__.Test'>
从执行结果可以很明显的看初，self代表的是类的实例，代表当前对象的地址，self.__class__则指向类。self不是Python关键字，我们把它换成runoob也是可以正常执行的，但是一般不建议这样做，遵从开发约定共识。?
二、创建实例对象
实例化类其它编程语言中一般用关键字new，但是在Python中并没有关键字，类的实例化类似函数调用方式。以下使用类的名称Employee来实例化，并通过__init__方法接收参数。
class Employee:
'雇员类'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print ("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print ("Name : ", self.name, ", Salary: ", self.salary)
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
三、访问属性
可以使用点号.点来访问对象的属性。使用如下类的名称访问类变量：
emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)
完整示例代码：
class Employee:
"雇员类"
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print("Total Employee %d" % Employee.empCount)
执行以上代码输出结果如下：
Name : Zara , Salary: 2000
Name : Manni , Salary: 5000
Total Employee 2
如果在Employee类的__init__初始化构造方法中添加age变量，则可以添加、删除、修改类的属性，如下所示：
emp1.age = 7 # 添加一个 'age' 属性
emp1.age = 8 # 修改 'age' 属性
del emp1.age # 删除 'age' 属性
也可以使用以下函数的方式来访问属性：
hasattr(obj,name)：检查是否存在一个属性
getattr(obj,name)：访问对象的属性
setattr(obj,name,value)：为对象的属性赋值，如果该属性不存在，则会创建一个新属性
delattr(obj,name)：删除属性
hasattr(emp1, 'age') # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age') # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(emp1, 'age') # 删除属性 'age'
四、Python内置类属性
__dict__：类的属性（包含一个字典，由类的数据属性组成）
__doc__：类的文档字符串
__name__：类名
__module__：类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__等于mymod）
Python内置类属性调用示例代码如下：
class Employee:
"雇员类"
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
print("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__dict__:", Employee.__dict__)
执行以上代码输出结果如下：
Employee.__doc__: 雇员类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__dict__: {'__module__': '__main__', '__doc__': '雇员类', 'empCount': 0, '__init__': <function Employee.__init__ at 0x00000270577E2DC0>, 'displayCount': <function Employee.displayCount at 0x00000270577E2E50>, 'displayEmployee': <function Employee.displayEmployee at 0x00000270577E2EE0>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>}
__bases__：Python为所有类都提供了一个bases内置类属性，通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组。注意是直接父类！！！
举例说明：定义三个类Vehicle（车）、Automobile（汽车）、Car（小汽车），为了说明问题，将Car设置为继承自Vehicle和Automobile两个类，而Automobile继承Vehicle，类定义示例代码如下：
class Vehicle:
def __init__(self, wheelcount):
self.wheelcount = wheelcount
class Automobile(Vehicle):
def __init__(self, wheelcount, power):
self.power, self.totaldistance = "燃油发动机", 0
super().__init__(wheelcount)
class Car(Automobile, Vehicle):
def __init__(self, wheelcount, power, oilcostperkm):
self.oilcostperkm = oilcostperkm
super().__init__(wheelcount, power)
print(Car.__bases__)
print(Automobile.__bases__)
print(Vehicle.__bases__)
输出结果：
(<class '__main__.Automobile'>, <class '__main__.Vehicle'>)
(<class '__main__.Vehicle'>,)
(<class 'object'>,)
从输出结果来查看这三个类的__bases__，得出结论如下：
1.Car的直接父类是Automobile、Vehicle
2.Automobile的直接父类是Vehicle
3.Vehicle的直接父类是object
注意：类的实例是没有__bases__属性的
五、类的继承
面向对象的编程带来的主要好处之一是代码的复用，实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类
继承的语法
class 派生类名(基类名)
...
在Python中继承的一些特点：
1.如果在子类中需要父类的构造方法，就不需要重写父类的构造方法
2.Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。(先在本类中查找调用的方法，找不到才去基类中找)
如果在继承元组中列了一个以上的类，那么它就被称作“多重继承”，其语法如下所示：
class SubClassName (ParentClass1[, ParentClass2, ...]):
...
继承的示例代码如下：
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print("调用父类构造函数")
def parentMethod(self):
print("调用父类方法")
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print("父类属性 :", Parent.parentAttr)
class Child(Parent): # 定义子类
def __init__(self):
print("调用子类构造方法")
def childMethod(self):
print("调用子类方法")
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值
以上代码执行结果如下：
调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200
也可以继承多个类
class A: # 定义类 A
.....
class B: # 定义类 B
.....
class C(A, B): # 继承类 A 和 B
.....
可以使用issubclass()或者isinstance()方法来检测
issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true
六、方法重写
如果父类的方法不满足当前的需求，则可以在子类重写父类的方法，示例代码如下：
class Parent: # 定义父类
def myMethod(self):
print("调用父类方法")
class Chlid(Parent): # 定义子类
def myMethod(self):
print("调用子类方法")
c = Chlid() # 子类实例
c.myMethod() # 子类调用重新方法
执行以上代码输出结果如下：
调用子类方法
后面的继续参考这个地方：Python 面向对象 | 菜鸟教程
|