22.python中的面向对象和类的基本语法

2022-10-29 19:05:53

　　当我发现要写python的面向对象的时候，我是踌躇满面，坐立不安呀。我一直在想：这个坑应该怎么爬？因为python中关于面向对象的内容很多，如果要讲透，最好是用面向对象的思想重新学一遍前面的内容。这个坑是如此之大，犹豫再三，还是只捡一下重要的内容来讲吧，不足的内容只能靠大家自己去补充了。

　　惯例声明一下，我使用的版本是 python2.7，版本之间可能存在差异。

　　好，在开讲之前，我们先思考一个问题，看代码：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAANIAAAAqCAIAAABJOpJhAAACFUlEQVR4nO2aYZKDIAxGufXeqZd0f3SqFgIJFQjKe7OzoyFFCt8khhK2POGDahxGvyH5fq/VYJbBgfvJLrxCeM017AmHNDnHZP1J+cVuHEnzNX7r5kq3yK6Kr8m6hfL6LfDPPaO5WuL5uoXyOoF6hnFJZBblWSrEkKB2K3TySZRn9ZSNaQ+5PlUjVCHPXSvlnQXUdW8iUlWtUb21fBzsdI92myHgNYx2kUV0yzlYZHd+FrL7me7vdruGxuzEqtHouuzEyAdV9K1kSbIg0n3f7nr2ND1FKh22TDYsVx5q8ZFzBjvMGjiA7MABZAcOLC27wVU27NzyKEAT0kN7XiNZkPsdBWgFsnNk0aMAoshQ3jAmOgoQXYsbfoVdwNQYdRU5i8NQvw40YZajAKLnReMmCa4wGGQ3jCmOAmwtZCdGwdxDkZ0vsxwFaBjtct2qdmQ3DIejAGLkE1ubJFnL2Mqe0ByHowCF963IIZc3xaxt99xbC7fQlannuncqNL4AQHPmnW5jSIM7wvqBA+c3oW22IDLhkKAJUQqTPMLxZzGmPrk+RbtqgQfwFe2E5iBcl41iq9inKjI091SUhTWGn5xcqoT1vkZqK6AvsiUCITuowvhjQ0lJqRHZQZmq3xuO/2JTelsrO0rXRZhFdmohAk+ioqS4WMn+4AlPRZedmPsKRvGz9h0+Uu0KsLzgALIDB5AdOIDswIF/hx6g9CYej/wAAAAASUVORK5CYII=" alt="" />

　　为什么我只创建是为 a 赋值，就可以使用一些我没写过的方法？

　　可能会有小伙伴说：因为 a 此时是个字符串对象呀，当然能够使用字符串的方法，至于这些方法，那是python事先写好的。

　　好吧，那换个问题，为什么 python 知道它是个字符串对象？

　　在深入讲这个问题之前，先记住一句话：python中一切皆对象，对象都是由类创建的。

　　那么类是什么东西呢？我在这举个例子。

　　有一天，我在街上走着，突然看见前面有一个仇人。此时我想揍他一顿，但是力是相互作用的呀，打他我的拳头也会疼。诶，此时我发现路边有个石头，大小形状正合适，在不考虑警察叔叔怎么想的前提下，这是一个好的选择。然后我抄起石头，对着仇人进行了一些好孩子不能模仿的行为，然后深藏功与名，收工回家。

　　在这个过程中，我们为什么会知道那块东西是石头？

　　因为它的具有石头的外观特征呀！

　　为什么我们会知道石头可以砸人？

　　因为石头硬呀！

　　为什么我们知道石头是硬的？

　　因为......嗯.....小时候我爸告诉我的。

　　此时可以得到一个结论：我们知道一个东西是什么，具有什么功能，是因为我们的脑海中已经有个这个东西的概念。而这个概念可能是从长辈那里知道的，也可能是自己各种实验后自己总结的。类似于我们对于‘黑洞’这个东西的认识，还是科学家的各种研究总结而来。

　　如何将用石头打人这个例子用代码来实现的话：

class Stone(object):　　# 我创建一个叫Stone的类

    def attack(self):

        print '把头伸过来，我给你加个buff'

a = Stone()   # 我用类创建了一个对象，也称为类的实例化

a.attack()      # 我使用这个对象的方法

aaarticlea/png;base64,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" alt="" />

　　很好，这样我们就完成了我们的需要了。

　　如果我们再创建其他对象：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZcAAABgCAIAAABe5KhPAAAH20lEQVR4nO2c7bLbKgxF/dZ9/PTHnZsmRhIbBDY4a03nTExAEl/b4OAeLwCAnTnuDgAAIAUqBgB780/F/hyGoumJF3MUMRz/U00EgCfxNb13ETJTrcrPZiIAPIzz3N5IyLxLU7BQMYCnktIsRciUPd1RoJht+goVA3gq9tweJWTz9nSeNe952UDXALAU09diL2E5Nmot1rpAA4AHMP25mPmsPY+55mrKDwDPYO5vlJftKPmNEuBnmX5erHWr2GSz6oXzYgCPh+kNAHuDigHA3qBiALA3qNiZST+qAsAkdn0bvA/lLYLgEgAWZPW3wYe/ToSKATyM1d8Gv1LFeAETYEeWeBvczGkeAQtOn8WJp6ddXmYzqmrkAHAjq7wN7uUUlcUsEifGRsSwAeB2lngbPMjZpCzmssssq5tFxQAWZ6G3weM1lJkzLu5l8yQVFQPYkRveBjdFpLqj1LeH3TvKMhEJA1ifG94GD5ZC5cN4L7/5bL4sHlxWxbS8BIAFYZae0bfAALACTFQA2BtUDAD2BhUDgL1BxQBgb1AxANgbVAwA9gYVA4C9QcUAYG9QMQDYG1QMAPYGFQOAvUHFAGBvUDEA2BtUDAD2BhUDgL35GRXjPwvbHXoQHD5GxnF8/ZvlMGe8rzgToBVzGOhjY9Iooh/B4lvFTn9n+cwZv13FFpxLk0Iyzeq+krersQbhuRTD4oKBcrGK/cKK4EdULGkTHkpNxd77gtMGId5xxDm9fato8zMecXdjWuvw3rTpHt50psHW5wBiH73TTQsipsFkI4tBwi+hjZJy2JWfr08Uh68Z/OffJu+639ecpquGF8cjOgrMdqvYkEZGs6Agca8zl0heHnH6iTaDqLz8ZnFlLmVu/sFiZGzT9Qm66a6aP1N901FTI6NiUNCrYuLKqJrYsdry9hoeGRULLHS49soObLrWeE7ps1Us6FmxkVExKOhSsfy2aEhi33TSVUxXW8Vvq6MZITXZ9Kwl7x+id/EGA3BWMW+1b+41zP1OkHOIzc9LfUV2Kv5OiYP34hRdV6vZmljWvYy2itjycV9UfXk5Y0emkVOK6Qt+m58ZAYz13aEHwYGRAQB7g4oBwN4sr2Kfj7F+jV+uO4BM+ww5PaCNn78qT4Kr7kqznrtuF7od/dn8Z3jmE+4ym1m8r45By8+QxaTNUf2YKSv+XjE1DOiid4aYn5X8HY6mSlifKVEdShXzms4ru4I6KF5un7r5AAaO5Ntb48dIq9iM/NfbHK5i8YrVNLJ+K63gaJ73sfdjhOxCcioWb5TK/ErmpgBO1j5tmoeSyvyfBju2inGi2VBK/lFUq3Nqojiz7qgpQj0kxXVw84gTS6dm5mr8QWaYQ+6ZS9/0bt2QtrqIt29eor77U2Lw7JTuYiNJxDib6q470lFC0v2+9ejVOxiCwLxLhOw+xq3FvJQyMbhbtgZgppSfg0kSFI/v6tWoqvPw+rWYmdhad92RTuY+5zXjNSrWekeHCQwSkfgrRQKSMTSpmFLEKxV8dTJSFYIZzRK7qPoVV0Cio+7iyZXgLWuxOCSYyd0qlunsqgzp3pOjOc6jxCm2Q+vqdYiK9elIJs6+ljl9zqtYdQ2e7E0YRHtzB+vncunhrUeCFUprMKUjL4+X8/My+Kq1mt66xrTZUeVqNiXOprpXfQ2JMwipaupdpLwM4vQaqvygjGQk7HKe0uLB0HnSqNqlLrvECY/gEaMtvscCwKNhkgPA3qBiBd7zLABYkh+bqNU9Zt8jagC4j+VnqakjGXFBxQCexfKz9EoVG+4LAOYzf4p2HzvST2YFjrxjXPoRJ1QMYG0mT1H9NKCXU1QWs0icGBuJEwFgGS6ZoplT4E3KYi67zLK6WVQMYG0u2VGePjTl7JCbqop5koqKAWzIHTtKU0SqO0p9e9i9oywTkTCA5bnw6f5bvIKlkPnk3lO94EF++WtAeVkV0/ISANaDWVqgb4EBYAGYqACwN6gYAOwNKjYN8XDJ7TbhSSw4QuaHpJ38zDqpParP2w/O9N9IcK5tuE2loH7weDhL9csFzB7zousrCap5v4oNP0XVVFbMXD1idj35MMS+yBgcQkcfLc4WY36So+He5/e7dbBAOW2wWo9uNEN0ZixaZ/C8PtpizOe5t5rjCFUsPoHlneoKjmuVFk5lSzuxhVPkr5ca0inRs+nl7Ka13TKbEc+X0p7VxGofmfG8isYUHQUV1G0GRnYc801kqtlUqXyo7Qxdi3mhBwZP9Y8/x8WDhq7GGXif0RlBkHHd+1yIxqtdoPeRF1JpqiPOPpte8ernauJdY14nWU09ePPb+WiKa5STE8v0fI96N4HYV2xT9D4EXUOHuOhTsaCRg4KtIZ3cnVL6bLa2oek99lW1f8GYbyVTzbJ4UPZaCXt9qdiQ+5LtZNp9qdW1YhMV81xPUrFgYlQt51VML7XamG9iVDWrKpbR2V5aVKx7xDT1qHe76AvjGSrWEcZAFdMbOY5z7KCaV3xIeBeMeZ1kNZNF5vPdjv/5LgXV1FczT5B4FL7Knv4MIPAeGKw6ir2LObsp4+xo+VZfpnczf1zcS1TiDKoZtEneZhVz5Hg1WmfMt5KpZrVS5WUm1HYulUxYmguHHcBAGLg/T/ImD3A3s8bucRwHEwMA5oOKAcDe/BOaP5bo6Ilnu6gYAFzCl9AMFDJUDACu4S9XaRv/PwYhPAAAAABJRU5ErkJggg==" alt="" />

　　很显然python并没有为我们准备 attack 方法，所以就用不了。

　　所谓的类只是一个抽象的定义，而实例则是具体的对象。它们之间的差别就想我脑海中的石头和我手中的石头一样，只有后者才真实存在。当然，这里不要跟我讲什么唯心主义论什么的。

　　看到这里，关于类和对象之间的关系应该清楚了一些。有些同学可能会问：python中的类都是我们事先写好的，有没有方法让python自动生成类，然后在特定的时候使用这些类呢？恭喜你，同学，你可能摸到了人工智能的门槛了，如果能够实现的话，那和我们人类的学习能力不是差不多吗？好吧，这只是我的一个设想，真正的人工智能要怎么实现，我也不知道，还没有这么高的水平去研究先，不过作为一名程序员，能够编写人工智能，可能是终身的追求了吧。

　　在讲完类和实例化是怎么一回事之后，我们来看看类的基本语法。

　　首先，和定义函数的 def 一样， class 是定义类的关键字。

　　紧接着的是类名，这个可以自定义，同样的，不能和python的内置关键字冲突。另外，建议避开python的内建类型，例如 str、int之类的名字。规范的命名应该遵从“驼峰命名法”，例如： MyClass 这里的命名，每个单词的首字母大写。

　　然后是一个括号，里面的参数是用于继承的，一般继承于 object，表示一个新式类。另外，你可能见过没有括号的写法，这是经典类的写法。

示例：

class NewClass(object):

    pass

class OldClass:

    pass

New = NewClass()    # 创建一个新式类的实例

Old = OldClass()    # 创建一个经典类的实例

　这就是类的基本语法，当然这样还是不够的，但是在更深入之前，我想先讲一个新旧式类的差别。

　在这里，我们先打印一下两个变量的类型：

print type(New)

print type(Old)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYYAAAAtCAIAAAAlTlsrAAADuElEQVR4nO3d75niIBCAcbo6StgOrgLp4xqgmptmjmK8DwkJ/4KJITruvr8P3poni3OsTAB1NHcAUMO8OwAAWJGSAChCSgKgiNqUJM44eXcQH44+xOc5lZKCt8YYc8nzXpz1YXyzsXHFY3Vcr17ah8Al9qQkcb3RccXwDt5eOpiCv41vXtyUR2JK2fs/iOdnWeh8r7b7sP+3BN7uYUp6ODZUzzheS9ycVQ70SZI50knNdb3K3wuq9VNS8Pbh05en+EKccU7kSJ9kc5ngffytS3uVBR306qWkxjN3WWRsLzHqU8TFhck6HyiPnBe8NcZaa4y93ezacBnP/NhFdM57ezocccaJeB+SPpkffmpYnDHOOTPfur+bqefiXt1zrQHeoZOS6tESvK0XJsVpy936h07LQ4gz1oflthNGHfM0ik8GNv26eO9jO8skaE7v0z/inASRUEdSNFXfHdWrzG2hVH/htjUwOuekF+viip5eu+sj580ZIbntxNMf8GcCCP5m7dqgyR5dnPXercHkm9AhbO4ljexV8hH0OrS9vcySOrse8e56rvh1YbF1ZIhmSqrj2Y55TEqaFllVxpnTjbhplbgcTre3N5fDA3uVfATVDr4JIF6rp1GUvHxtsheLzLyhY6z/13iRu/my91lTo8lOTQypiCeZuMRFaLxTbjM96pbszOS1/zT9VZtA4pzc52Vb84xLe5U3AUA5te/eBvATfUpKSjdlJl9f5ZFR1/9XPhaAzKekJAA/AikJgCKkJACKkJIAKEJKAqAIKQmAIqQkAIooSUn6P+WgP0LgO1CTkpoVEBVlAWoMAa9wvtDteVtlbS8pR/sUisYCL3K40G1SA0CpF0aoah4HfAdHC93qH4QvjpAFHTDSkUK32cdRpyKt8ROo8cc/a2mQpLBGVux1n33laMvSrnmERc2OpBRJVda2riO7P2aKxgLjHCp0Wx9cs1YsIBa/pWPdfimLve72sBztvggbJWKLduoCvodi1j9zBD7GoUK3jSPz2F13etsp4KmaHntqPzaLvfZLxO6sY70zZvIRMNLR7e14VyRf4aQ5wvrQnCWltaX3eDzfaZV2LSJslIit2qkL+O6MmXwEDHb0TQCtb4fOFjfipm8uSk9pfNXS48fMZymNcrR/26VdqwjTErG/br+rdtLme7tL3X4BMMSAt0rmI5OJA4DnnUlJjer58yFeFwfwFCUfKAGA+52UBEAVUhIARUhJABQhJQFQhJQEQBFSEgBFSEkAFCElAVCElARAkf+YJd+hOxfM2QAAAABJRU5ErkJggg==" alt="" />

　　可以看下两者的输出是不同的。

　　在早于python2.2的版本时，只有经典类这一种写法，当时，类和类型没有合并。

　　类是类对象，实例是实例对象，这两个对象之间没有任何关系。

　　这句话是什么意思？看代码：

print type(OldClass)

print type(Old)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAANMAAAAzCAIAAACCIaoMAAAC6ElEQVR4nO2bwXnjIBCFp6ulk63AlJF82wDVhPtWsYelmOQgJBCMECiSZxS//2RjGcbwPIzwM31eyz9Lb0Tv1l88TjfevhG9k/kbYoO6CF8Ekg4AvChQHpABygMyQHlABigPyADlARmgPCCDEuV5S8oP1PRHeDPUKM+40LwiOENEdP7ye7vZba62/QjBED3K8/bab3twpnNVL0o8W90GZ6Z2PsKr5+Vns6u8clWCc3LT/WTlXfdGsKO85Uu/IDvX2pT3iV34MC3llZM6VUQR+zE/t355yf6xRGStJSJKb4412uASzZVdpoo6AZeXpBjn0eqWKh5v65izD7cfJxLfOA3lsZmgaEzi9G564O20XKk0Wh4NpYfgzDTSuswvRo9P6weNTzHHkyKsY27MQA323CO0d9v9hYyLlYptVg0pU3avUI/u876LrJcrqGhp6HVL2aNxgn1G7zDmp97PjdPWlS98kVGyTBLCeM7L72k2gknXzpk3E1PVwua8ooUdbndywACjpyrcsdpqF/WWjDHrS5iKrWvYvDxb+mCqMfN4GCLj/udXxbHqFqbOc847Uwe4IyycqnyHE06S1wvwg9JASqXgfL6jPOb2Lzbd+6BhKR7v/TGUo+TXM/ByQHlABigPyADlARmgPCADlAdkgPKADEqUp//8WX+EN0ON8ljPr6LFhg/vZDS74YN7KFlsuOHP515u+C6eGKGqrHwz7uWG7+HJEWIXPohWN3zpRoj/TXTOFCbP1Y/76wgLm9TscGb6YXxc/THDDX8ItW54bqwohIb3nX0X45Fe91M774di1r8PaEStG74eixUc631vO+Y7/73RGTNkdxC1bvjtoVtO9zpCxjFf9VM77ztjhuyOo9UNnyWdrD4jsn4pAT9Yp3sdYe6Y//X4XfWTd9+q/JrzAkaBGx7IADc8kEHJr2fg5YDygAxQHpABygMyQHlABigPyADlARmgPCADlAdkgPKADFAekAHKAzJ8AV/DsMvdZEb9AAAAAElFTkSuQmCC" alt="" />

　　我们可以看见其输出很含糊，经典类属于类对象，无论是哪个类，都统一为“类”类型，实例属于实例类型，却不知道其是由哪个类创建的，所以的实例都统一为“实例”类型。也就是说当时的类型用 classobj 和 instance 代表了所以的类和实例，无论你是哪个类，又或是哪个类创建的实例。

　　这样的信息实在太少，而类和类型之间非常混乱。为了解决这种情况，在 python2.2 中引入了新式类，并进行了类和类型的同统一。

print type(NewClass)

print type(New)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAR8AAAAvCAIAAABVOFkDAAADOklEQVR4nO2c25njIAxGKYsSppGoj22AalbNLMVkHwg2BpLPF+TEmXMeMjZDgBD9XBQLdwcAG9y7GwDwtaAuACtQF4AVqAvACtQFYMWnqUvFiV6sZIA+n6cuH+LFSgbos0ldKrajfwzeSAH9kq0/D/xy1qurXlnFEE4zTbO6WC6CISvVFYOvrPBMuzStixUjWLFKXbUBqrgZ+ZvvRad/yR9xzomIc87Nb47BLxPW1G1eVzt0AIxgjbq6U0eVOAtQQ7pQSRqYtzzT1dbpwrou1odgwsqVYWt/7TbM+xALR8GUobyYZ6Et1mxaF9ICK3Z7NfKtak5MS7Epj0palXXmk/s9xj1z1/i6kBYYstsj/9jWPFmy3ZPFe7/Mkt+00aSt6sIjD6aM/DV5aay208KZdQHsY4i6Cj9elTTe2X1mXQCH+LQnoQC+B9QFYAXqArACdQFYgboArEBdAFagLgArPl9d/FJ8HPrwPYxRV+9RpVGYxl99tNmN61Vi2N7DwMh/C0u1Owsgl38bX7xKkkRWx9pPMD0ZWQrqeK9y6sHb2B/5vz3D7yHHm23pk0IE5VTDIVkXZnfkfwvf1oSKE1Hd0ieLGaY4R4RTDy7Mrsj/eze+oxPjWGWZQxrnUbpOOU4M3qWAFH+7+bnguj3188DpXkLwh5uj4kQ1hFj0yeIkApV8VoGI5BMNuioy7lVOPbBkX+R/DL5d+TwJr+xcvCh5CCmYcnp90Yy2zckgDzYsvV1DCLmc+iSC9EdFNKrGtiVVUe3tqF5lxWHIvsj/NSdtlENoNc6WI2qbcpyHcRevL9rz2naPNCCGm/fPTiJQ8SHI3Jil72GOpzbtVaRlyz6vxjR3vdgh5Ns5bz5jpjDiJmUIXXW17Xne5jHqSqu4RjwP5aikZeiUXHo1nq63B/Yq0jJnr0c+j6DJIApfslu4u9xj8+N8+NfxOHd90Ed5nLkx72pyk6r2FNNJXuXmm06I5stuWeQsHPGlkpsNk4ro/bEu7OYw7VU88ifw+c9qAFyVy6mr3MAkfn7qlFGj8pl1wRdyOXUBXAbUBWAF6gKwAnUBWIG6AKxAXQBWoC4AK1AXgBWoC8AK1AVgxX8eIf31M7h0agAAAABJRU5ErkJggg==" alt="" />

　　我们可以知道实例是由哪个类创建的了。

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQQAAACKCAIAAADDp6NBAAAFTklEQVR4nO3czXKrMAyGYe763Ea3vdqcRZgMxX9yMJKQ3me6aF1qpTNWgADf9vv7+4IT27Z/DQdxg41mAN7iNMO26L1z1Tx4nHoz/KstCPmgvrUrmH7IqblnuKMffrYf+SubIlm+8uo0Q069w6Tl/XBTMwjX7lR1+iGhwTnDqn742X6OX6fBcoPTluX2f/6HovRphtacpw36cyK88Qn0wv1DuY5PS3N28O20cFtbVvcM1e4q50QGSnuGt9ZyfAlWcGeP0dozyKuXaIaE7M8Z5M3Qmra1cMujLOFL6syJwGw+Teov09nDpNfftTvVVxwj4UP7OoPkAGb2BPpVNENry+oJNGfPeHNxBVpyPDPEFWhcZNkMs2//wK1c7BkADzw2g9oNy9wZjaNxM5gsF7WiZSHaI61BM5TPmShoVVleXa0QHqHXDN7eNTWr0w8JNZuh9ezh8Tj7+ONpg7UPMJpUpx+yqTeD/PjhOHJcpsLBKfrV6YdUpHuG4WBrtZVv5F9/hqNcnU7IZsE5g3w5XqRZnU5I6MtPk/qfMt19mHR3dTohp+nrDNXDjM7ZdnX8awrV6YS01lyB7r9V3822OsK41Aw3vf0/ojri8XhvEmAiTjPwPAMuCpuod+WJCPohp0SJelU8A40P+3SM666sXdIx8BEwUU+YnNcpVM6JDAIm6lW3ObVB5yV15kRsMRP1ylpTmZOtORGb/TnDTYl6NANmBUzUk8/Zmp9OyCl4ot7p7Lw6CYl6eHNxBZpEPXhAoh6wc7FnADzw2Axq92BzszeOSNQzKw1vSNTTKIRHIFHPvhacIFGvVxSpkKg3VxGBkag3Vw6Bkag3UQuxkajXK4RUSNQbzIY8SNQDdiTqATuP9yYBJuI0w63PIfCQQwYBE/U6T0QQs4eOsIl6V2oRs5eTfTrGdZJ0jClEZuQUMFHvs7Hkb1vRAcTsJZQlUa86SJgSjrIk6rUGJdE1/UIIw/6cQSdRrz+JMKuGZogtS6KevFCrKJ0QXopEPcng8HXSDOG5uALtKlFPf3I4QaIesHOxZwA88NgMavdgc7M3jkjUMysNb0jU0yiERyBRz74WnCBRr1cUqZCoN1cRgZGoN1cOgZGoN1ELsZGo1yuEVEjUG8yGPEjUA3Yk6gE7j/cmASbiNAPPM+CigIl6zy0BWzET9e4oRDOEZ5+Ocd3abMmpQogkWqKeWiHEEzNRT60QIomZqKdWCJHYnzPI12hr2uXNIC+ESGIm6t1RiE4IL2Ci3k2FaIbwXFyB7r9/C0kW69eF6IQMUiTqqRXCo7nYMwAeeGwGtXuwudkbRyTqmZWGNyTqaRTCI5CoZ18LTpCo1yuKVEjUm6uIwEjUmyuHwEjUm6iF2EjU6xVCKiTqDWZDHiTqATsS9YCdx3uTABNxmmHVIwfDedQKQVnYRL3qyJtkUFhIPqfwRcJQzES9/vr+fF8dLGcbziOck2Zwzj4d47rqkpI0g3D7/uDpV51Cs3NCWbREvf6gfHsPc0JZzES91mB1XH4A0xoUbkwzOBczUW9qsPortT+nGfywP2e4Kehu9mx1YTPId0rDVwVNMRP1yhHzT5MkLxK2YibqlZ/0b391tixnMykEfS6uQKsl6i2ZR60QlKVI1AMkXOwZAA9oBmDXCwTYxE8LcPSLAMZRMZ/vq4OvV709gMeZeAa61Qzlj8ATfRk8TDMgnkFukqQTqiPA43wTFTPcBniiuWZoLXqaAQEs+DSp/BF4oonrDFsju7d18QF4Fq5AAzuaAdjRDMCOZgB2QRL1gOtUn4EGPFNNxwA8U81NAjxTTdQDPPsPgEWaUjZcwv0AAAAASUVORK5CYII=" alt="" />

　　类的类型是 type？type 返回的对象还能像类一样创新新对象？

　　关于类和类型统一的问题，可以参考这篇文章：戳这里

　　总结的来说：在新式类中，所以的类对象都是 type 的实例。而不同的类对象有能创建出其对应的实例。

class NewClass(object):

    def __init__(self, val):

        self.val = val

New = NewClass(123)

b = type(New)(321)  # 对实例来说type返回的是类对象，我又可以用类对象来和创建新的实例

print b.val

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOYAAAA4CAIAAABmPBOzAAAEQ0lEQVR4nO2bzZHbMAyFURZLSCNGGXIF4U2npANdl3dVoQs7cBPKgaT4K5vWWspi5n2TcWyZJCDwCYRoLa0AiIL+twMAvMcnJGtnpWb73VEWpoFoMh9wqOLne3gNZqIPxOEjth5aPQ/mwjvfvpSsG/pOdCde9tuMOvHOcOhCd35jhne9fIadFQ25rcRnH7XSw6Mc8vBEemYna8zGzw6b1eqxr+NBx8J07AXteTAf+tZW/AvJWj0q/fAG9i+apFnujZ3V0zm2ek6+PSCI5MTMFK7aRQefTRiu8rCXb3t4Ip2z44lpbzuL004nTbF2VjS0MtdB6y8kmyanZPIqY+XK2ynZYpwD55B2KbtnajtYG3zfw/N49M6Ob1ynvZNOJ7W1rmYinriRy8+RbP+ghtMryZV922LtP7JxufBONH35N+5fjKDWI9E9ZkS/7ru58dVk2cY1rDK9zhukHhoeiCbmIYxzhYcZjV6jtnm5nLWpeWfKs8qyIdlYy+XZ0VsPMTH+4H6v0pYL+0OrxFU3mhoVTX/0SDQqNZCabmrwEdvMRYdjVD8m2dVMSVVURzOuXEbXsYueBQG54yGRxBxZt1nX5rpv5nKmSw8HNvnIZ3qYsyXIzaib1LSAq9sU9Es2T3sNydZD1dYXpoGaa+kzW34cw0GOacRo+loX9teqe91bM2NU3ygMVvt4urA+W6PXTVVmasWu+PjWmzQcEcN1NJsexoPnediK1ZDnb3cwTajNNimP3tkpb96bHm6Zfs9683SKXk1bRSbOrH/5j+lr4WTp8zu3X69uLZOVd/f6o6YfZtmZ7GYOy9pYPW4Ke1XPFR4WI5/lYYtEbV5qIcvGBbRuU9I3O0Xay8+9umEtzytab6ycrV65LTvfQjYx7AYMI5uJzpBsso3ScRfiV97QpV7OzJSnw9CSl3g58pKVMo2aL23z91dMBvdWudb00DUYlQr164kebrOSs+3NbSOr2YaizTTaNOmYndb+qN/eam4LbrZS60lZn8Sn6tVOsVmVb9ZQqvLENJD6TXRnnrZXt9Dlm6R5VHdicYxiaStpLdYXs3m4l4b/u4efpU6x4m1d84Ntcj/+M/C3ullW/lkegj3wjAEQBiQLhAHJAmFAskAYkCwQBiQLhAHJAmFAskAYkCwQxivJGqYAh+edVHHEN8QvR+AKXj0vq8IjA1Yr4q/V6ls4YtiL1ssakgVX0F0YGCY223/poeo9ACfSI1nDrRxqtVLJk72QLLiGd7OsJ9dr9TUAp9G/YxBFaZhU9XdVkCy4hu7br6BTq1XyhysatSy4mP5NLqfIZNOLyCfbeiMMgNPATwlAGJAsEAYkC4QByQJhQLJAGJAsEAYkC4QByQJhQLJAGJAsEAYkC4QByQJhQLJAGJAsEAYkC4QByQJhQLJAGJAsEAYkC4QByQJhQLJAGJAsEAYkC4QByQJhQLJAGJAsEMY/qNqgG2DhwEsAAAAASUVORK5CYII=" alt="" />

构造器方法

　　一般可以理解类中的函数就是方法，而方法分为：实例方法，只有实例化后才能调用的，其第一个参数一般为 self，代表实例本身；类方法，其第一个参数为 cls，代表类本身；还有静态方法，就是个普通函数，没有要求参数。

1. __init__(self [,arg1,....]):

　当类被调用进行实例化的时候，python会自动调用类里面的构造函数（如果有的话），在构造函数中，可以进行各种初始化的操作，最常见的就是上面的进行实例的属性的创建。

　　python 在示例化的时候，会检查其实行了 __init__ 方法了没有，如果没有则不对实例进行任何操作，然后返回对象。如果实行了这个方法，则自动调用这个方法，并自动将 self 传进行，也就是说我们在实例化进行传参的时候，将不用理会 self，直接传给后面的参数。

　　讲到属性，就必须要提一下什么是属性。属性其实更像一个变量，大多数对象都可以有属性（不包括python的内置类型），例如函数。

def Test():

    pass

Test.a = 123

print Test.a

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOoAAAAcCAIAAADgPbQdAAAA90lEQVR4nO3ZsQ2DMBBG4RvLC+XGgA08TdxnijQeJmkcDBEkBgknv/S+Cg4kXDxZAuzRw91tMBs9dXlag+SD2Wjhlsvg71aIFvbrBQDHkS+EkS+EkS+EkS+EkS+EkS+EkS+EkS+ENeWbfPY3KsdgRZkmt7cJ0MW3fEuaU5Y5XmKul/z6SB5ekxwDAaOjlt03eY1y63h9AJxqb75VjmHadssuTbvo62C+y3Y/3Aic6Ei+yW2l3bU7gVPtzjfHMHuPi4tXt+2ugTM0fnmYvj7Mzs1KrHXG1ouu+G0BYeQLYeQLYeQLYeQLYeQLYeQLYeQLYeQLYeQLYU9BIfDub7ZjdgAAAABJRU5ErkJggg==" alt="" />

　　因为函数也是一个对象。

　　属性在类中，就是一个变量，但是，函数名也是一个变量名。所以，所谓的属性就是：属于一个对象的数据或者函数元素。

　　例如：

class NewClass(object):

    a = 123

print NewClass.a

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOYAAAAqCAIAAAAoIrAjAAAECElEQVR4nO2awZWjMAyGVZZL2EaiMkgF6xun3Q64ju9UwcUdpAn2gI1lIxKHgez4vf978/ICI1tC/pFtAs0ANAWd040fjRn9d3uZmDqiwZ0RUcnPj/AzuIFOyMMpvh7WPE/mxNp/ayS7dH0nuhNP+za9FdE5jk3ozm+MsB7lC/xoqMt9iZhD1soIj3IowgupGZ3MmF0YHXazt31dw4OBxeHYS9rzZD7sTVH8a8l62xv7CA72bxphlkfjR/N0jL0dxX8PCEJcmBviXTvZGLOL3W0irOXbEV5I5egEUtlbr+Kyy5El1o+GOq1yHfH+WrKyOInB2zgrZ95KyRb9HLgG2aRsnqnt4Nrg+xFex6N2dILxtuxddDnS1zy7gXhgpZZfI9n6Th3LO2lZ9q2TdThkt9TCO9HwFb4sfymD1vZE91QRw7y/jE1YTZY2i+Gm0tvcQEbouCMamLvYzycizFBa9dbny+XMZss7Q56tLBXJprVcXh2D95gTF07utyp9LWl/WCNCXXozvaHhj+2JemM6MsPNdCFjq7sUcMzqyyt9LynpTtpmM81czm5zlyKLAlrOx0KSauTWZp7Ved+N5UiXEXbs8p6vjDBnLZCr02VQ5QJua1NQL9m87CmS3Xa19T4xdaTOpc98hX4cRznKjNHwNU8c7tXlc2/ODFl9b2Ew+8fTifXZHD2vqnKDlrvi8K0vMh0Jx9tsqhGmk9dFqOWqy+v3clIWVNVG8qgdnXLzrka4Vvo97+rlFK1UX0Ulzrx/hUP5WQSZHb65/Xq1tRQz7+79R6oC3LQz2GoNy2y87VeFvVrPFREWPV8VoYZQW5BarLJpAt3alNSNTlH28mvfbFjL60relZlTa5X78uMtVhPHS4exZzfQFZIVj1EqdiFh5o1NttOZG/JyGC15SrcjT9lSRlnzSZu/v1IxuGvLNTXCxaA3Jq5fL4xwHZWc9dnc2rMZfVy0OcVGpWJ0tOej4fGW+lhw9SW9i2W9yM+mlV5is1W+m+NSlQemjsxvojvzsH4uE13+kDRl9aSfErIQnz3+1CbrD7NGuFeG/3uE57ItsW37Ol2ye4j9+M8gbHWzqvyzIgQqH5MsAOcAyYLGgGRBY0CyoDEgWdAYkCxoDEgWNAYkCxoDkgWNUStZx+JXIW8NBTi+SUXFGQCuoUKyQY7iZalbfInAMRF/zY5NPOOtgWjBlVRWWcckXufXv+snADiXA5JNeGuMeLOXsSwA13NcsrlenxgCcCYHJeuYFL1qlgCcyxHJemvEXsxm2699LQNwCvVPDNanBuKYKAg0nUOJBdeCnxJAY0CyoDEgWdAYkCxoDEgWNAYkCxoDkgWNAcmCxoBkQWNAsqAxIFnQGJAsaAxIFjTGPwpFCq7OEdzTAAAAAElFTkSuQmCC" alt="" />

　　当然，因为 python 的特性，我们可以在运作中为某个对象添加属性，而不用一开始就在类中写定。

　　注意，这个方法应该返回 None，也就是说我们一般不用 return 任何对象，让它默认返回就行了。

2. __new__(cls [,arg1,....]):

　　这也是一个构造器方法，它是一个类方法，一般在对 python 的不可变数据类型进行继承扩展的时候用的比较多。

某处拿来的代码示例：

class RoundFloat(float):

    def __new__(cls, val):

        return super(RoundFloat, cls).__new__(cls, round(val, 2))

a = RoundFloat(3.14159)

print a

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAARYAAAAmCAIAAACOIiMBAAAEfElEQVR4nO2bzZXjIAzHVRYlbCNRGU4Fy82X3e2A63B3Fb64gzTBHgw2HzJmQpLNzvx/b17eTCJASAgJnKFfAIAOyAEAOkAIAdAFQgiALrpDaJmUmpbeXmamgcjY3n4k3l/D12ANPcAODxnrplXdmDOfm7pF5hXUQ2id6pXoSjwfy4w6spbl0ISu/Ikp3mWRZVI0pGNFOnsv5hrey7v4LNDinUSYrfcOW7fosa3hnYoFdxwZrW7Mm76cRnuLzCuohdCiR6VvzjnnZj7eVCIx54VX6yyTqq65RU/Rp3cs0MiI1oRdbdZBZxu6KzRspVvDJ9LoHc+eFrZZPG06cQpaJkWDtJO+yJipB5/SqhZC8eYddVpMPq+UGkMo6+cOm8ZN8uaJFe6s5fo1fB63Vu944TItPGk68VjOWUNsWMh1rzHmfaN8rlUthNo7shzvNOuxYSuu/J9s11xxJTIf/pf1Z/eo1iPRdc8Yvk5b14o/jeQyq2CRCXUqEGtoeSAyzEPo5xUaJgitRr2kx61EpuQzbk5OJkII7bV3mj386MEm1r953CofazX7TatI1bU3NSoyv/VINCo1kDIXNXiLbcPtChdWzWUkfVIPfhzMwhe020FA8PuJNR4TQs6aqKouvbtXGlaXvtwtFRb0+n7YaPccUsp4K+Tr1U75yss1HNimPT9Tw5QtgWyDrossLu5LmYz2EErTghBCZVfl6DPTQGKtURvL92M5hEdsMTIfbma/d6yvRzWFaNWWGkHo52AWlZ5lL2/9tBZybrlVC6FaTeW2VW6N5MujybT8Ertnx3LdmkI/z9NQstWQ73N+MdVlYm6t3skvx44WTZzxytGPFmiaJ4WxskyVjP7h/4xfMyXrOhc7dZ63G8JsTzvtoycCzdcJZ1c3UaV0uD+RqJmdD/QToz+RWfS4rfiz80CmYdbzszSUiFa/X/ohC+0FTymT0+adLC2kcy8uYPJ57aML61VqlY61TJewu1leOww9W0MPDqFSH3fswaLn5Nyetap42bnmS+2GU7WvlEKTsvywJk0XQZLnfbviOSlzhTNDLPPnx75ZXqVyX9RwFRiVGii7dn+8htsqSdnu4ree1bSEot8KMiIN3pGez+TVv3g5Ho8eHQ8i+xSt5BSUnBKtC7s+G6aB1E+iK7PZXtdCIH0oIlk1lzmYRexBeRbb2cxc1BA9BRkka8Rnob2fB347IStFcqTi6sVsGh6lqX+u4WMpU9DXGOu9eMEXfOb9vus98Fc3SdZ6Lw3BfwS+IwdAFwghALpACAHQBUIIgC4QQgB0gRACoAuEEABdIIQA6AIhBEAX1RCyTIH6k3vL5eeWTxoB8BWo/r+QCl95W7Q6igcfZvmnlk/jDoCvQFshd5JRio8tEzOyEPgOnIZQSzrJQsiy0gsKOfA9eHwWCucihBD4FjTeyNXjIf40uoJouIcA4H+n7TrBMqnqf9MJkYIsBL4FjZfacZIpbg7KhLNo5d+rRR4AXwA8WgWgC4QQAF0ghADoAiEEQBcIIQC6QAgB0MVfOONVMk3UPRQAAAAASUVORK5CYII=" alt="" />

　　关于类的继承以后再讲。

　　这个方法不同之处在于它必须返回一个合法的实例。这里的 cls 也是自动传递的。

解构器方法

__del__(self [,arg1,....])

　　这个方法将会在对象所以的引用被清除后才执行，例如：

class Test(object):

    def __del__(self):

        print '我被干掉了，兄弟们为我报仇！'

a = Test()  # 创建了一个对象

b = a   # b又引用了a

c = b   # c又引用了b，现在 a 所指向的对象有3次引用，相当有三条命

del a   # 干掉一条命

del b   # 又干掉

del c   # 听说你有3条命？全部干掉！

aaarticlea/png;base64,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" alt="" />

　　注意，这里只输出了一次，也就是说到了最后才删除完毕。这里要注意一下几点：

　　1.调用 del 并不意味着完成删除某个对象，只是减少引用。

　　2.如果你有一个循环引用或其它的原因，让一个实例的引用逗留不去，该对象的__del__()可能永远不会被执行。

　　3.__del__()未捕获的异常会被忽略掉（因为一些在__del__()用到的变量或许已经被删除了）。不要在__del__()中干与实例没任何关系的事情。

　　4.一般情况下并不用实现这个方法，因为这样有一定的风险。

　　5.如果你定义了__del__，并且实例是某个循环的一部分，垃圾回收器将不会终止这个循环— —你需要自已显式调用 del。

　　6.如果继承了父类，且父类中也有解构器，要记得调用。否则可能会有某些在父类中的清理方法没有调用到，出现以下无法预料的错误。

码农公寓

构造器方法

解构器方法

相关文章