14 python面向对象类

-----------1， 类的定义，创建实例，类属性----------------------------------------

class person(object):## 默认继承了object基类，这是所有类的基类
    """docstring for person."""

    def __init__(self, arg1,arg2):  ## 构造方法定义（实例化时自动调用）
        self.pid=arg1     ## 这是类的实例属性（而不是类的属性）
        self.name=arg2
        myname=arg2    ### 这个叫做局部变量（前面没有加self. 也没有声明globle），只能在本方法内部使用，（类中的其它方法都是没法使用的）

    name1="huang"   ## 类属性定义（只能通过类名访问）

    def __del__(self):  ## 析构函数（对象释放时自动调用）
        print "类析构"

    def run(self):
        print "我是普通方法"

p=person(1,'jim')  ##类实例化
print (p.pid,p.name,p.name1)   ## 实例属性只能通过实例来访问
print person.name1 # 类属性可以通过类名来访问
p.run()




-----------1， 类的构造方法----------------------------------------

    1.使用一个名为__init__的方法来完成初始化。
    2.使用一个名为__del__的方法来完成类似析构操作。
    3.所有的实例方法都拥有一个self参数来传递当前实例，类似于this。
    4.可以使用__class__来访问类型成员
    5，python不支持构造方法重载，也不支持普通方法重载。（重载即是方法名一样，而参数不一样，调用方法时，会跟据参数类型，自动识别调用哪一个方法）
   
    __init__()     
       #构造函数，如果不自定义，python会自动给出一个默认的
    
    __del__()
       ##析构函数，也是可选的，如果不自定义，python也会自动给出一个默认的

    del (对象名)：
         ##显示的调用析构函数




### ！！！  类中函数和普通的函数相比：
    在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。
    除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。


-----------1， 类的方法 的调用----------------------------------------

2,python类的方法的调用

   #1.类的内部调用：
      self.<方法名>(参数列表)。
   #2.在类的外部调用：
      <实例名>.<方法名>(参数列表)。


3，类看方法和属性的调用。  
   例如：
      class Test:
            first =123     ## 类属性
            __second=456   ##  私有属性：前面加__变量名  例；__money  （__也算是变量名的一部分，并不是标识符）
                            ##只能在类内部访问（当然可以通过接口函数进行访问修改）
            def func (self):  
                self.name='jim'  ## 实例属性
                return "test_class"
     则：
       mile=Test()    --实例化对象，返回类的对象（即对象的句柄，也即是对象的名字）
       mile.func()    ---对象调用类中的方法
       mile.first     ---对象访问类中的属性
       Test.first     ---类名访问类中的属性

       mile.__second   ---在类的外部使用对象不可以访问类的私有属性   XXXXX!
       Test.__second   ---在类的外部使用类名不可以访问类的私有属性   XXXXX!


###############实例方法， 类方法，静态方法################################

实例方法：只能通过类的实例化对象访问 ## 用的多
类方法：  |
           ----》 二者在使用上没有区别，都是只能使用类直接访问  ## 用的较少,但是静态方法不能有self，（类方法是和普通类一样要有self的）
静态方法：|



     

1,类中的实例方法（即实例方法）   
      class CLA():
          def fun1 (self):   ##必须要有self 
              print ("thhis is XXXX !!")
      
      a=CLA()
      a.fun1()  ##只能使用对象来访问 
      
2,类中的静态方法

class person(object):## 默认继承了object基类，这是所有类的基类
    """docstring for person."""
    def __init__(self, arg1,arg2):  ## 构造方法定义（实例化时自动调用）
        self.pid=arg1     ## 这是类的实例属性（而不是类的属性）
        self.name=arg2
    name1="huang"   ## 类属性定义（只能通过类名访问）
    def __del__(self):  ## 析构函数（对象释放时自动调用）
        print "类析构"

    def run(self):
        print "我是普通方法"

    @staticmethod ## 加此标识 ，则成了静态方法（静态方法不能有self）
    def func():   ## 静态方法不能有self，
        print "我是静态方法"

    @classmethod   ## 加此标识成了类方法(类方法是要有self的)
    def func2 (self):
        print "我是类方法"
        

p=person(1,'jim')  ##类实例化
print (p.pid,p.name,p.name1)   ## 实例属性只能通过实例来访问
print person.name1 # 类属性可以通过类名来访问
p.run()   ## 通过实例访问。实例方法
p.func()   ## 可通过实例访问静态方法
person.func()  ## 可通过类名访问静态方法
      
3,类方法                        
       class cla:
           def func (self):
               print ("xxxxx")
           mr=classmethod(func)  ##生成新的类方法
       
       cla.mr()  ##可以直接使用类名来访问
            说明：
            classmethod() 函数的参数只参是类中的普通方法，否则会语法错误
         ---
       class cla:
           @classmethod     ##使用装饰器
           def func (self):
               print ("xxxxx")
       cla.func()     ##也是可以变成类方法的，直接被类来调用
       






############ 内部类 极少用 ####################
class Milo():
      class Test():
            def fun2 (self):
                print ("this is in !!!")        
      name="cvst"
      def fun1 (self):
           print ("thhis is out !!")
         
a=Milo()
a.fun1()
b=a.Test()  
b.fun2()
--------
a=Milo().Test()
a.fun2()
------- 
a=Milo.Test()
a.fun2()
###以上三种方式使用内部类都是可以的 ！！！类的实例化必须有括号（）