python_day7学习笔记

Posted 2020-07-30 Jasongo

• 类

1）创建一个类

 1 #coding=utf-8
 2 __author__ = ‘Administrator‘
 3 
 4 class Employee:
 5    ‘所有员工的基类‘
 6    empCount = 0
 7 
 8    def __init__(self, nm, treatment):
 9       self.name = nm
10       self.salary = treatment
11       Employee.empCount += 1
12 
13    def displayCount(self):
14      print "Total Employee %d" % Employee.empCount
15 
16    def displayEmployee(self):
17      print "Name : ", self.name,  ", Salary: ", self.salary

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

2）创建实例

1 "创建 Employee 类的第一个对象"
2 emp1 = Employee(‘Zara‘, 2000)
3 "创建 Employee 类的第二个对象"
4 emp2 = Employee(‘Manni‘, 9000)

3）访问实例属性

1 emp1.displayEmployee()
2 emp2.displayEmployee()
3 print "Total Employee %d" % Employee.empCount
4     
5 输出结果：
6 Name :  Zara , Salary:  2000
7 Name :  Manni , Salary:  9000
8 Total Employee 2

• 类的继承

 1 class Child(Employee): #定义子类
 2    def __init__(self, nm, treatment, test):
 3         Employee.__init__(self, nm, treatment)
 4         self.ad = test
 5 
 6    def displayEmployee(self):
 7         Employee.displayEmployee(self)
 8         print "Test :",self.ad
 9     
10 创建实例及访问属性方法：
11 emp1 = Employee(‘Zara‘, 2000)
12 emp2 = Child(‘yd‘,800,900)
13 
14 emp1.displayEmployee()
15 print "Total Employee %d" % Employee.empCount
16 emp2.displayEmployee()
17     
18 输出结果：
19 Name :  Zara , Salary:  2000
20 Total Employee 2
21 Name :  yd , Salary:  800
22 Test : 900
23 从结果可以看出，子类继承了父类实例方法输出。
24 也可以继承多个类，如class C(A,B)，继承类A和B

• 内置类的属性

 1 __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
 2 __doc__ :类的文档字符串
 3 __name__: 类名
 4 __module__: 类定义所在的模块（类的全名是‘__main__.className‘，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
 5 __bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
 6 
 7 print Child.__name__
 8 print Employee.__doc__
 9 print Employee.__module__
10 print Employee.__dict__
11 print Employee.__bases__
12     
13 输出结果：
14 Child
15 所有员工的基类
16 __main__
17 {‘__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>}
18 ()

• 对象的销毁

 1 析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__del__方法运行。
 2 举例：
 3 #coding=utf-8
 4 __author__ = ‘Administrator‘
 5 
 6 # Filename: SchoolMember.py
 7 # 面向对象的实例，学校成员类
 8 
 9 class SchoolMember:
10    # 总人数,这个是类的变量
11    sum_member = 0
12 
13    # __init__方法在类的对象被创建时执行
14    def __init__(self, name):
15       self.name = name
16       SchoolMember.sum_member += 1
17       print "学校新加入一个成员：%s" % self.name
18       print "现在有成员%d人" % SchoolMember.sum_member
19 
20    # 自我介绍
21    def say_hello(self):
22       print "大家好，我叫：%s" % self.name
23 
24 # __del__方法在对象不使用的时候运行
25    def __del__(self):
26       SchoolMember.sum_member -= 1
27       print "%s离开了，学校还有%d人" % (self.name, SchoolMember.sum_member)
28 
29 # 老师类继承学校成员类
30 class Teacher(SchoolMember):
31    def __init__(self, name, salary):
32       SchoolMember.__init__(self, name)
33       self.salary = salary
34 
35    def say_hello(self):
36       SchoolMember.say_hello(self)
37       print "我是老师，我的工资是：%d" % self.salary
38 
39    def __del__(self):
40       SchoolMember.__del__(self)
41 # 学生类
42 class Student(SchoolMember):
43    def __init__(self, name, mark):
44       SchoolMember.__init__(self, name)
45       self.mark = mark
46 
47    def say_hello(self):
48       SchoolMember.say_hello(self)
49       print "我是学生，我的成绩是：%d" % self.mark
50    def __del__(self):
51       SchoolMember.__del__(self)
52 
53 t = Teacher("老黄", 3000)
54 t.say_hello()
55 s = Student("小河", 77)
56 s.say_hello()
57 
58 结果输出：
59 学校新加入一个成员：老黄
60 现在有成员1人
61 大家好，我叫：老黄
62 我是老师，我的工资是：3000
63 学校新加入一个成员：小河
64 现在有成员2人
65 大家好，我叫：小河
66 我是学生，我的成绩是：77
67 小河离开了，学校还有1人
68 老黄离开了，学校还有0人

• 类的私有方法

 1 举例：
 2 #coding=utf-8
 3 __author__ = ‘Administrator‘
 4 
 5 class people:
 6     name = ‘jack‘  #公有的类属性
 7     __age = 12     #私有的类属性
 8 
 9 p = people()
10 
11 print p.name             #正确
12 print people.name        #正确
13 print p.__age            #错误，不能在类外通过实例对象访问私有的类属性
14 print people.__age       #错误，不能在类外通过类对象访问私有的类属性

• 静态方法和类方法

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

 1 #coding=utf-8
 2 __author__ = ‘Administrator‘
 3 
 4 class people:
 5     country = ‘china‘
 6 
 7     #类方法，用classmethod来进行修饰
 8     @classmethod
 9     def getCountry(cls):
10         return cls.country
11 
12     @classmethod
13     def setCountry(cls,country):
14         cls.country = country
15 
16 p = people()
17 print p.getCountry()    #可以通过实例对象引用
18 print people.getCountry()    #可以通过类对象引用
19 
20 p.setCountry(‘japan‘)
21 
22 print p.getCountry()
23 print people.getCountry()
24     
25 输出结果：
26 china
27 china
28 japan
29 japan
30 @staticmethod只能通过类对象引用，不能通过实例对象引用