类
一、面向对象——类
1.1、释义
类是面向对象的一个很重要的载体，是用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法，对象是类的实例。
1.2、类的定义
class StudentName(object):
pass
object是超级类，所有的类都是基于它而生成的，默认添加的
1.3、类的实例化
实例化：创建一个类的实例，指类的具体对象。
实例化类的首字母小写作为实例，然后类实例化：
studentName = StudentName()
示例：
class StudentName(object):
name = "jiang" #如果需要全局变量，就在类的内部直接定义
def hello(self): #类里面一般都是由很多函数组成，函数的第一个参数默认都是self
print("hello {0}".format(self.name)) #类的内部在调用函数或者调用变量的时候，必须使用self.变量名，或者self.函数
def test(self):
self.hello() #self代表的是类实例化以后的个体
print("This is test")
a = StudentName() #类的实例化
b = StudentName()
1.4、类的构造器
指的是类在初始化的时候，首先，必须要执行的函数
示例：
class StudentName(object):
def __init__(self, name): #__init__()方法称为构造函数或者初始化方法
self.name = name
print("init class A")
def hello(self):
print("hello {0}".format(self.name))
a = StudentName()
1.5、继承与重写
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）
重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
class Animal(object):
def __init__(self):
print("你现在正在初始化一只Animal")
def run(self):
print("Animal can run")
class Bird(Animal): #继承Animal
def fly(self):
print("Bird can fly")
class Cat(Animal):
def __init__(self): #重写构造函数，在调用的时候会先去找子类中方法，如果子类中没有再去父类中调用
super(Cat, self).__init__() #使用super可以同时调用父类和子类
print("我是一只猫")
def jiao(self):
print("miao miao miao miao")
def run(self): #重写run
print("猫会跑")
class BianYi(Cat, Bird): #多继承，如果父类中都有该方法，那么先继承谁的就用谁的方法
pass
animal = Animal()
cat = Cat()
bainyi = BianYi()
1.6、私有变量和公有变量
class DbArgs(object):
__host = str("1.1.1.1") #'__'两个杠号表示只能类本身才可以调用（私有变量）
__port = str("3306")
name = "jiang" #这个表示任何人都可以调用（公有变量）
_username = "jwq" #'_'一个杠号表示只能实例本身自己调用
def getHost(self):
return self.__host
def setHost(self, host):
self.__host = host
dbargs = DbArgs()
dbargs.name = "weiqing" #公有变量可以随便修改
print(dbargs.name)
print(dbargs.getHost()) #私有变量只能通过自身函数调用才可以
print(dbargs._username) #实例化后可以调用
1.7、封装
class InitStduents():
def __init__(self):
self.students = list()
self.init()
def init(self):
self.students.append(Student(1001, "aaa", 59))
self.students.append(Student(1002, "bbb", 96))
self.students.append(Student(1003, "ccc", 87))
self.students.append(Student(1004, "ddd", 89))
self.students.append(Student(1005, "eee", 33))
self.students.append(Student(1006, "fff", 85))
self.students.append(Student(1007, "ggg", 78))
self.students.append(Student(1008, "hhh", 97))
self.students.append(Student(1009, "iii", 31))
self.students.append(Student(1010, "jjj", 93))
def sort(self):
return sorted(self.students, key=lambda student: student.score)
def writeFile(self, newStudents):
with codecs.open("sortStudent.txt", "w")as f:
for i in newStudents:
f.write("id = {0}".format(i.id))
f.write("\t")
f.write("name = {0}".format(i.name))
f.write("\t")
f.write("score = {0}".format(i.score))
f.write("\n")
def main():
students = InitStduents()
newStudents = students.sort()
students.writeFile(newStudents)
if __name__ == "__main__":
main()
1.8、super函数
super() 函数是用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
Python3.x 实例：
class A:
pass
class B(A):
def add(self, x):
super().add(x)
Python2.x 实例：
class A(object): # Python2.x 记得继承 object
pass
class B(A):
def add(self, x):
super(B, self).add(x)
示例：
# !/usr/bin/python
# -*- coding: UTF-8 -*-
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print('Parent')
def bar(self, message):
print("%s from Parent" % message)
class FooChild(FooParent):
def __init__(self):
# super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
super(FooChild, self).__init__()
print('Child')
def bar(self, message):
super(FooChild, self).bar(message)
print('Child bar fuction')
print(self.parent)
if __name__ == '__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
执行结果：Parent Child HelloWorld from Parent Child bar fuction I'm the parent.
