python_day7学习笔记

• 类

1）创建一个类

 #coding=utf-8
 __author__ = 'Administrator'

 class Employee:
    '所有员工的基类'
    empCount = 0

    def __init__(self, nm, treatment):
       self.name = nm
       self.salary = treatment
       Employee.empCount += 1

    def displayCount(self):
      print "Total Employee %d" % Employee.empCount

    def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

在Employee类的定义中，定义了三个方法：__init__()和displayCount()、displayEmployee()。其中__init__()初始化实例参数。

2）创建实例

 "创建 Employee 类的第一个对象"
 emp1 = Employee('Zara', 2000)
 "创建 Employee 类的第二个对象"
 emp2 = Employee('Manni', 9000)

3）访问实例属性

 emp1.displayEmployee()
 emp2.displayEmployee()
 print "Total Employee %d" % Employee.empCount

 输出结果：
 Name :  Zara , Salary:  2000
 Name :  Manni , Salary:  9000
 Total Employee 2

• 类的继承

 class Child(Employee): #定义子类
    def __init__(self, nm, treatment, test):
         Employee.__init__(self, nm, treatment)
         self.ad = test

    def displayEmployee(self):
         Employee.displayEmployee(self)
         print "Test :",self.ad

 创建实例及访问属性方法：
 emp1 = Employee('Zara', 2000)
 emp2 = Child('yd',800,900)

 emp1.displayEmployee()
 print "Total Employee %d" % Employee.empCount
 emp2.displayEmployee()

 输出结果：
 Name :  Zara , Salary:  2000
 Total Employee 2
 Name :  yd , Salary:  800
 Test : 900
 从结果可以看出，子类继承了父类实例方法输出。
 也可以继承多个类，如class C(A,B)，继承类A和B

• 内置类的属性

 __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
 __doc__ :类的文档字符串
 __name__: 类名
 __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
 __bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

 print Child.__name__
 print Employee.__doc__
 print Employee.__module__
 print Employee.__dict__
 print Employee.__bases__

 输出结果：
 Child
 所有员工的基类
 __main__
 {'__module__': '__main__', 'displayCount': <function displayCount at 0x0253EA30>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x0253E870>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x0253E930>}
 ()

• 对象的销毁

 析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__del__方法运行。
 举例：
 #coding=utf-8
 __author__ = 'Administrator'

 # Filename: SchoolMember.py
 # 面向对象的实例，学校成员类

 class SchoolMember:
    # 总人数,这个是类的变量
    sum_member = 0

    # __init__方法在类的对象被创建时执行
    def __init__(self, name):
       self.name = name
       SchoolMember.sum_member += 1
       print "学校新加入一个成员：%s" % self.name
       print "现在有成员%d人" % SchoolMember.sum_member

    # 自我介绍
    def say_hello(self):
       print "大家好，我叫：%s" % self.name

 # __del__方法在对象不使用的时候运行
    def __del__(self):
       SchoolMember.sum_member -= 1
       print "%s离开了，学校还有%d人" % (self.name, SchoolMember.sum_member)

 # 老师类继承学校成员类
 class Teacher(SchoolMember):
    def __init__(self, name, salary):
       SchoolMember.__init__(self, name)
       self.salary = salary

    def say_hello(self):
       SchoolMember.say_hello(self)
       print "我是老师，我的工资是：%d" % self.salary

    def __del__(self):
       SchoolMember.__del__(self)
 # 学生类
 class Student(SchoolMember):
    def __init__(self, name, mark):
       SchoolMember.__init__(self, name)
       self.mark = mark

    def say_hello(self):
       SchoolMember.say_hello(self)
       print "我是学生，我的成绩是：%d" % self.mark
    def __del__(self):
       SchoolMember.__del__(self)

 t = Teacher("老黄", 3000)
 t.say_hello()
 s = Student("小河", 77)
 s.say_hello()

 结果输出：
 学校新加入一个成员：老黄
 现在有成员1人
 大家好，我叫：老黄
 我是老师，我的工资是：3000
 学校新加入一个成员：小河
 现在有成员2人
 大家好，我叫：小河
 我是学生，我的成绩是：77
 小河离开了，学校还有1人
 老黄离开了，学校还有0人

• 类的私有方法

 举例：
 #coding=utf-8
 __author__ = 'Administrator'

 class people:
     name = 'jack'  #公有的类属性
     __age = 12     #私有的类属性

 p = people()

 print p.name             #正确
 print people.name        #正确
 print p.__age            #错误，不能在类外通过实例对象访问私有的类属性
 print people.__age       #错误，不能在类外通过类对象访问私有的类属性

• 静态方法和类方法

类方法：是类对象所拥有的方法，需要用修饰器"@classmethod"来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以"cls"作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。

 #coding=utf-8
 __author__ = 'Administrator'

 class people:
     country = 'china'

     #类方法，用classmethod来进行修饰
     @classmethod
     def getCountry(cls):
         return cls.country

     @classmethod
     def setCountry(cls,country):
         cls.country = country

 p = people()
 print p.getCountry()    #可以通过实例对象引用
 print people.getCountry()    #可以通过类对象引用

 p.setCountry('japan')

 print p.getCountry()
 print people.getCountry()

 输出结果：
 china
 china
 japan
 japan
 @staticmethod只能通过类对象引用，不能通过实例对象引用