1 -----------1， 类的定义，创建实例，类属性----------------------------------------
2
3 class person(object):## 默认继承了object基类，这是所有类的基类
4 """docstring for person."""
5
6 def __init__(self, arg1,arg2): ## 构造方法定义（实例化时自动调用）
7 self.pid=arg1 ## 这是类的实例属性（而不是类的属性）
8 self.name=arg2
9 myname=arg2 ### 这个叫做局部变量（前面没有加self. 也没有声明globle），只能在本方法内部使用，（类中的其它方法都是没法使用的）
10
11 name1="huang" ## 类属性定义（只能通过类名访问）
12
13 def __del__(self): ## 析构函数（对象释放时自动调用）
14 print "类析构"
15
16 def run(self):
17 print "我是普通方法"
18
19 p=person(1,'jim') ##类实例化
20 print (p.pid,p.name,p.name1) ## 实例属性只能通过实例来访问
21 print person.name1 # 类属性可以通过类名来访问
22 p.run()
23
24
25
26
27 -----------1， 类的构造方法----------------------------------------
28
29 1.使用一个名为__init__的方法来完成初始化。
30 2.使用一个名为__del__的方法来完成类似析构操作。
31 3.所有的实例方法都拥有一个self参数来传递当前实例，类似于this。
32 4.可以使用__class__来访问类型成员
33 5，python不支持构造方法重载，也不支持普通方法重载。（重载即是方法名一样，而参数不一样，调用方法时，会跟据参数类型，自动识别调用哪一个方法）
34
35 __init__()
36 #构造函数，如果不自定义，python会自动给出一个默认的
37
38 __del__()
39 ##析构函数，也是可选的，如果不自定义，python也会自动给出一个默认的
40
41 del (对象名)：
42 ##显示的调用析构函数
43
44
45
46
47 ### ！！！ 类中函数和普通的函数相比：
48 在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。
49 除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。
50
51
52 -----------1， 类的方法 的调用----------------------------------------
53
54 2,python类的方法的调用
55
56 #1.类的内部调用：
57 self.<方法名>(参数列表)。
58 #2.在类的外部调用：
59 <实例名>.<方法名>(参数列表)。
60
61
62 3，类看方法和属性的调用。
63 例如：
64 class Test:
65 first =123 ## 类属性
66 __second=456 ## 私有属性：前面加__变量名 例；__money （__也算是变量名的一部分，并不是标识符）
67 ##只能在类内部访问（当然可以通过接口函数进行访问修改）
68 def func (self):
69 self.name='jim' ## 实例属性
70 return "test_class"
71 则：
72 mile=Test() --实例化对象，返回类的对象（即对象的句柄，也即是对象的名字）
73 mile.func() ---对象调用类中的方法
74 mile.first ---对象访问类中的属性
75 Test.first ---类名访问类中的属性
76
77 mile.__second ---在类的外部使用对象不可以访问类的私有属性 XXXXX!
78 Test.__second ---在类的外部使用类名不可以访问类的私有属性 XXXXX!
79
80
81 ###############实例方法， 类方法，静态方法################################
82
83 实例方法：只能通过类的实例化对象访问 ## 用的多
84 类方法： |
85 ----》 二者在使用上没有区别，都是只能使用类直接访问 ## 用的较少,但是静态方法不能有self，（类方法是和普通类一样要有self的）
86 静态方法：|
87
88
89
90
91
92 1,类中的实例方法（即实例方法）
93 class CLA():
94 def fun1 (self): ##必须要有self
95 print ("thhis is XXXX !!")
96
97 a=CLA()
98 a.fun1() ##只能使用对象来访问
99
100 2,类中的静态方法
101
102 class person(object):## 默认继承了object基类，这是所有类的基类
103 """docstring for person."""
104 def __init__(self, arg1,arg2): ## 构造方法定义（实例化时自动调用）
105 self.pid=arg1 ## 这是类的实例属性（而不是类的属性）
106 self.name=arg2
107 name1="huang" ## 类属性定义（只能通过类名访问）
108 def __del__(self): ## 析构函数（对象释放时自动调用）
109 print "类析构"
110
111 def run(self):
112 print "我是普通方法"
113
114 @staticmethod ## 加此标识 ，则成了静态方法（静态方法不能有self）
115 def func(): ## 静态方法不能有self，
116 print "我是静态方法"
117
118 @classmethod ## 加此标识成了类方法(类方法是要有self的)
119 def func2 (self):
120 print "我是类方法"
121
122
123 p=person(1,'jim') ##类实例化
124 print (p.pid,p.name,p.name1) ## 实例属性只能通过实例来访问
125 print person.name1 # 类属性可以通过类名来访问
126 p.run() ## 通过实例访问。实例方法
127 p.func() ## 可通过实例访问静态方法
128 person.func() ## 可通过类名访问静态方法
129
130 3,类方法
131 class cla:
132 def func (self):
133 print ("xxxxx")
134 mr=classmethod(func) ##生成新的类方法
135
136 cla.mr() ##可以直接使用类名来访问
137 说明：
138 classmethod() 函数的参数只参是类中的普通方法，否则会语法错误
139 ---
140 class cla:
141 @classmethod ##使用装饰器
142 def func (self):
143 print ("xxxxx")
144 cla.func() ##也是可以变成类方法的，直接被类来调用
145
146
147
148
149
150
151
152 ############ 内部类 极少用 ####################
153 class Milo():
154 class Test():
155 def fun2 (self):
156 print ("this is in !!!")
157 name="cvst"
158 def fun1 (self):
159 print ("thhis is out !!")
160
161 a=Milo()
162 a.fun1()
163 b=a.Test()
164 b.fun2()
165 --------
166 a=Milo().Test()
167 a.fun2()
168 -------
169 a=Milo.Test()
170 a.fun2()
171 ###以上三种方式使用内部类都是可以的 ！！！类的实例化必须有括号（）
