面向对象-类

类的使用

类的概念

类是定义同一类所有对象的变量和方法的蓝图或原型

类里的预定义方法

__init__()  '构造器'方法
    任何所需的特定操作，都需要程序员实现__init__()，覆盖他的默认行为。
    在实例化一个对象时，实例对象作为第一个参数（self)被传进去，并且会自动执行这个方法。
进行属性的初始化。
    **注:学过c++的都知道this指针，这里可以把self称为this**
__new__()   '构造器'方法
    继承自object的新式类才有__new__
    与__inti__()相比，__new__()方法更像一个真正的构造器，这是因为__new__()必须
返回一个合法的实例
    __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
    __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，
可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
    __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上
可以完成一些其它初始化的动作，__init__不需要返回值
    若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行

class A(object):
    pass

class B(A):
    def __init__(self):
        print "init"

    def __new__(cls, *args, **kwargs):
        print "new %s" % cls
        return object.__new__(A, *args, **kwargs)

b = B()
print type(b)

输出：
new <class '__main__.B'>
<class '__main__.A'>

__str__()   返回对象的字符串表达式
    在我们编写一个新的Python类的时候，总是在最开始位置写一个初始化方法__init__，
以便初始化对象，然后会写一个__str__方法，方面我们调试程序。

    class Person(object):
        def __init__(self, name, gender):
        self.name = name
        self.gender = gender
        def __str__(self):
            return '(Person: %s, %s)' % (self.name, self.gender)

    s = Person('Bob', 'male')
    print s

    输出：
    (Person: Bob, male)

__del__()   '解构器'方法
        python中是自动管理内存的，管理内存的机制是通过引用计数进行管理。
    当一个对象被创建出来的时候，引用计数为1，当该对象被其他变量或者对象
    引用是，引用计数会+1。
    当对象引用被删除时，引用计数会-1。
    当对象计数为0 时，就会执行__del__()方法，系统会在合适的时候将所占内存释放。

        >>> class new(object):
        ...     def __init__(self):
        ...         print 'v'
        ...     def __del__(self):
        ...        print 'x'
        ...
        >>> n1 = new()
        v
        >>> n2 = n1
        >>> del n2
        >>> del n1
        x

定义一个类

类：新式类和经典类，新式类必须继承至少一个父类。（尽可能的使用新式类）
class 类名（）:  
    内容

class people():
        def __init__(self,name,age):
            self.name = name
            self.age = age

        def prt(self):
            print self.name

    pe = people('tom',19)
    pe.prt()

输出：
tom

类的属性（更改，添加）

更改 ：更改这个类的某个属性
添加 ；只能给这个类的对象添加一个属相，其他的类对象都没有这个属相

  class people(object):
        def __init__(self,name,age):
            self.name = name
            self.age = age

        def prt(self):
            print self.name

pe = people('tom',19)
print pe.name
pe.sex = 'man'   #给pe对象添加一个性别属性
print pe.sex

pr = people('jack',18)
print pr.name
#print pr.sex
#当执行上一个语句时出现属性错误：AttributeError: people instance has no attribute 'sex'

输出：
tom
man
jack

私有化

类中变量,属性,函数的私有化
私有变量 私有函数 都只能在类中使用
如果需要在类外使用：（在子类中一样使用）
对象.类名_变量名

class bank(object):
    bankName = u'建设银行'   #类共公开变量
    __boss = u'兟'          #类私有变量

    def __init__(self, a, b):
        self.user = a
        self.money = b
        self.__passwd = 'abc'

    def printUser(self):   #打印类的属性
        print self.user

    def printBankName(self):  #打印类公开变量
        print self.bankName

    def printBoss(self):     #打印类私有变量
        print self.__boss

    def __sBankName(self):    #私有函数打印公有变量
        print self.bankName

    def __sBoss(self):       #私有函数打印私有变量
        print self.__boss

ban = bank('tom',18)

ban.printUser()
ban.printBankName()
ban.printBoss()
ban._bank__sBankName()
ban._bank__sBoss()
print ban._bank__boss   #打印私有变量

输出：
tom
建设银行
兟
建设银行 tom
兟
兟

如何在子类中访问父类中的私有变量和私有函数
如果类的继承忘了可以看看下面的继承

class bank(object):
    bankName = u'建设银行'   #类共公开变量
    __boss = u'兟'          #类私有变量

    def __init__(self, a, b):
        self.user = a
        self.money = b
        self.__passwd = 'abc'
    def bankUser(self):
        print self.user

    def __sBankName(self):  # 私有函数打印公有变量
        print self.bankName

class addMoeny(bank):
    def __init__(self,a,b):
        super(addMoeny,self).__init__(a,b)

    def printBank(self):
        print self._bank__boss      #访问父类 私有变量
        print self._bank__passwd    #访问父类的私有属性

        bank.bankUser(self)

        # bank.__Bankname(self)   #如何访问父类私有方法

ad = addMoeny('lxshen',100)
ad.printBank()  

输出：
兟
abc
建设银行

@classmethod 和@statmethod 的区别

继承和多继承

继承描述了继承的属性如何‘遗传’给派生类，一个子类可以继承它的基类的任何属性，不管是数据属性还是方法。

class people(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def prt(self):
        print self.name
class man(people):
    def __init__(self,name,age,sex):
        people.__init__(self,name,age)
        '''
        重写__init__不会自动调用基类的__init__
        可以用上面的方法执行父类的__init__
        也可以：
            super(man,self).__init__(name,age)
            用super的漂亮之处在于，你不需要明确给出任何基类名字。
        这就意味着如果更改了类继承关系，只需要该一行代码（class本身）
        而不必在大量代码中去查找所有被修改的那个类的名字。 
        '''
        self.sex = sex

    def printSex(self):
        print self.sex

n = man('lxshen','18','man')
print n.sex   #访问父类的属性
n.prt()      #访问父类方法
n.printSex()  #访问自身方法

输出：
man
lxshen
man

重写父类对象函数

重新写了父类方法，是因为父类方法功能不满足自身类的需求。所以需要重写

    class bank(object):
    def __init__(self, a, b):
        self.user = a
        self.money = b
    def printUser(self):   #打印类的属性
        print self.user

class addMoeny(bank):
    def __init__(self,a,b):
        bank.__init__(self,a,b)

    def printUser(self):
        bank.printUser(self)    #保留父类中的函数部分功能,如果没有这一行，就是完全重写父类方法
        print u'重写printUser'


am = addMoeny('jack',19)
am.printUser()

输出：
jack
重写printUser

   面向对象是每种语言的重中之中，今天把所学的知识点整理了一下，发现还有一些零碎东西没有掌握，
在整理的过程中也巩固了知识。可能还有一些东西没整理到位，如果发现错误希望大家指出来。
也希望自己以后越学越扎实吧。