对象、类-Python类型和对象 -by小雨

wwweducn

浏览: 29677 次

最近访客更多访客>>

tonghq

libankling

jmctian

everbao

博主相关

博客

微博

相册

留言

关于我

文章分类

全部博客 (44)

社区版块

存档分类

对象、类-

最近研究对象、类-，稍微总结一下，以后续继补充：

关键字：Python 类型对象
原文：http://wiki.woodpecker.org.cn/moin/PyTypesAndObjects

关于本书

解释新式的Python对象（new-style）:

<type 'type'> and <type 'object'>是什么货色
用户定义的类及例实是如何互相联关的，和内置类型有啥关系how user defined classes and instances are related to each other and to built-in types
metaclass是什么

新式类型New-style含包在Python2.2及以上，包含3.x。这些本版之间会有微细差异，不过这里涉及到的念概都是无差别的。本书讲的容内常通被称作Python类型统系或Python对象模型Python type system, or the object model.

本书是以下系列的一部份:
1. Python Types and Objects [即你所看到的]
2. Python Attributes and Methods

This revision: 1.24

Discuss | Latest version | Cover page
Author: shalabh@cafepy.com

图引索

示例引索

要需提早解了的

该应注意的一些:

本书涵盖新式 new-style 对象 (在Python 2.2中引入). 本书例子用适于Python 2.5 及以上，包含 Python 3.x.
本书不是为完整初学者写的. 而是针对已对Python有所解了 (稍稍解了便可) 并希望对它解了更多的人.
本书为握掌新式（new-style）属性拜访及descriptors, properties等机制供提了所需的底层的要点。如果只对属性方法感兴趣，请移步至 Python Attributes and Methods, 读阅以后也就解理了本书的 Summary.

python之旅快活？Happy pythoneering!

1. 基本念概

入深Object

怎样精确的抒发python中object的含意呢? 统系中每个对象是一条规矩 - 是一个实体的体现. 可以通过如下特征来肯定一个对象:

有标识名字 (i.e. 给定两个名字我们可以断判他们否是指向同一个对象).
有值 - 对象可能含包一堆属性 (i.e. 比如可以通过 objectname.attributename取得其他对象).
有类型 type - 每个对象有一个肯定的类型. 例如对象2的类型是 int ，对象 "joe" 的类型是 string.
有一个或多个 bases. 并非有所对象都有bases，一些别特的对象会有. A base 类似于面向对象术语中的类超或类基。

如果你更在乎体具的对象在存内中怎样寄存，而不是更想晓得一些抽象的念概，
这对你解理每个对象在存内中都有个体具的位置（可以用id函数来取得）很有助帮。(---注：这句瞎解得，没真正解理，附原文)
If you are more of the 'I like to know how the bits are laid out' type as opposed to the 'I like the meta abstract ideas' type, it might be useful for you to know that each object also has a specific location in main memory that you can find by calling the id() function.

==== type 和 bases === (如果存在的话) 很要重，因为它们定义了对象和其他对象之间的特定关系. 请住记对象的types 和 bases只是另外一些对象.很快就会看到这一点.

你可能会想到对象有名字但名字不是对象的一部份. 对象名在对象以外的命名空间中存在(比如函数的当地变量) 或者作为另一个对象的属性.

即使对2这样一个简略对象所含包的货色也比我们眼睛看到的要多.

Example1.1. 看查integer对象

>>> two = 2   1
>>> type(two)
<type 'int'> 2
>>> type(type(two))
<type 'type'> 3
>>> type(two).__bases__
(<type 'object'>,) 4
>>> dir(two) 5
['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', 
 '__delattr__', '__div__', '__divmod__', '__doc__', '__float__',
 '__floordiv__', '__format__', '__getattribute__', '__getnewargs__',
 '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__',
 '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__',
 '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__',
 '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__',
 '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__',
 '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__',
 '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__',
 '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__',
 'conjugate', 'denominator', 'imag', 'numerator', 'real']

1 在前当命名空间中我们把这个integer命名为two.
2 <type 'int'>. 这是另一个对象, 当初来剖解一下. 注意这个对象也被称为 int 而 <type 'int'> 只是它打印出来的子样.
3 <type 'int'> 的type是另外一个叫做 <type 'type'>的对象象.
4 <type 'int'> 的bases属性是一个tuple，这个tuple含包一个叫 <type 'object'>的对象. 我想你没斟酌过检查 bases这个属性 ;).
5 列出这个原始integer对象的有所属性来 - 很多多少货色啊.

耐烦点先来看我们的第一条规矩

规矩1

任何货色都是一个object

int 是 object. 这不是说例如2和77这样的数字是object (他们实确是)，而是说实确有另外一个对象叫做 int ，他处于存内中的现实的整数以外的存内中. 现实上有所的整数对象的class属性都指向 int，他们同共的心声是"知我者int也". 在一个object上用调type()方法回返的也恰好是这个对象的class属性的值.

我们定义的有所classes都是对象, 当然这些classes的例实也是对象.甚至我们定义的方法和函数也是对象. 并且像我们看到的，这些对象都有些不同.

空白状态

当初我们来从头构建python的对象统系. 我们从一个空白状态开始.

Figure 1.1. 空白状态

你可能在想为啥有两天灰色的竖线. 前面渐渐来发表. 竖线是来区分不同的区域的. 这个空白图中, 我们来渐逐加上各种对象，画上他们之间的关系，渐渐画满.

这个有助于助帮我们且暂置搁先入为主的各种有关面向对象的类和对象的观点，以对象的式方（我们这里的对象）来解理一切。

At this point, it helps if any preconceived object oriented notions of classes and objects are set aside, and everything is perceived in terms of objects (our objects) and relationships.

对象之间的关系

我们用使两种关系就可以连接我们所引入的这很多不同的对象. 这两种关系是子类-类父关系 (也可叫做别特化或继承, 如"人是个物动", 等等.) 和类-例实关系 (也叫例实化, 比如"Joe是个人", 等等.)。

如果你对这些念概已熟习了，可以续继往下看了,否则的话你可能要需先去看看这一部份“面向对象”.

2.引入对象

第一批对象

我们来看查<type 'object'> 和 <type 'type'>这两个对象.

Example 2.1. Examining <type 'object'> and <type 'type'>

>>> object 1
<type 'object'>
>>> type 2
<type 'type'> 
>>> type(object) 3
<type 'type'>
>>> object.__class__ 4
<type 'type'>
>>> object.__bases__ 5
()
>>> type.__class__ 6
<type 'type'>
>>> type.__bases__ 7
(<type 'object'>,)

1 2 这是python中两个最基本对象. 前面我们绍介过用type()来看查一个对象object的类型type(常通就是class属性的值). 其实,它本身是个对象，并且也是个看查其他对象类型的式方
3 4 5 看查 <type 'object'>: <type 'object'>的类型type是<type 'type'>. 我们也验证了它的class属性实确和用调type()是一样的.
6 7 看查 <type 'type'>: 风趣的是<type 'type'>的type是它自己! 它的bases属性含包了 <type 'object'>.

下面我们来画一下所看到的.

Figure 2.1. 鸡和蛋的关系

图中两个对象是python最基本对象. 也可以一次绍介一个，但这里有个鸡和蛋一样的抵触 - 先绍介哪个好? 这两个对象是互相赖依的 - 每个本身都不能独自存在，都要借助对方来描述自己.

还是续继我们的python试验吧:

Example 2.2. 关于 <type 'object'> 和 <type 'type'>的更多容内

>>> isinstance(object, object) 1
True
>>> isinstance(type, object) 2
True

1 看看发生了什么? 这是 Dashed Arrow Up Rule 的一个用应. 由于<type 'type'> 是 <type 'object'>的子类, 则<type 'type'> 的例实也是<type 'object'>的例实.
2 将 Dashed Arrow Up Rule 和 Dashed Arrow Down Rule 起一用使, 直接把箭头反过来也是精确的. （译注：事实上type，objcet的两两组合都是互为instance的）

如果对下面的证明不太解理, 不要紧 - 正反也没什么用.

再看一个新念概 - 类对象type objects. 我们绍介过的对象都是类对象. 所说的类对象是什么呢? 类对象有如下同共特色:

它们用来代表程序中抽象的数据类型. 例如, 用户定义的一个叫User的对象可能用来表现统系中有所的用户，另一个叫int的对象可能代表有所的整数.
它们可以被子类化. 你可以建新一个与已存在的类对象有点类似的新对象.已存在的类对象将成为这个新对象的类基.
它们可以被例实化. 意味着你可以建新一个已存在对象的例实. 这个新对象的class属性就是已存在对象.
任何类对象的类型是 <type 'type'>.
它们偶然被称为types偶然称为classes.

是的. Types和classes在Python中实确是同一个货色 (免责声明: 对老式类和早于2.2本版的Python用不适. 那是 types和classes有些不同但那时良久前的事了，当初已这些不同点已致一了。因此让去过的事就去过吧，不好吗?). 不要惊吃，用使type()函数和class属性到得的是一样的.

class 这个术语传统是指被class这个关键字创立的class. 内置类型 (比如int和string)常通和睦classes联系起来, 这更多是约定俗成的，现实上types和classes是同一个货色.我认为这点很要重，可以提出一个规矩:

Class is Type is Class

type和class这两个术语在有所Python >= 2.3的本版中是一样的.

类对象Types 和 (嗯，，让我想个更好的词) 非类对象non-types (呵呵!) 都是对象但只有types可以子类化. Non-types代表的是体具的值所以子类化并没有义意. 非类对象的两个例子是整数 2 以及字符串 "hello". 想想，2的子类是什么意思，没意思吧?

还对断判类对象和非类对象感到淆混吗？有一个简略的规矩:

类和非类对象断判规矩Type Or Non-type Test Rule

如果一个对象是<type 'type'>的例实, 那它就是类对象. 否则长短类对象.

回头看，可以证明这个规矩对我们所到碰的有所对象都是建立的, 包含 <type 'type'>，它是自己的例实.

总结一下:

<type 'object'> 是 <type 'type'>的一个例实.
<type 'object'> 不是任何类的子类.
<type 'type'> 是自己的例实.
<type 'type'> 是 <type 'object'>的子类.
python中只有两种对象: 为了清晰叫它们types 和 non-types. Non-types 也可以叫例实, 但例实这个术语也可以指向一个类对象, 因为一个type一定是另一个的type的例实. Types 也被叫做 classes, 并且我经常把他们叫做classes.

Note that we are drawing arrows on our slate for only the direct relationships, not the implied ones (i.e. only if one object is another's class, or in the other's bases). This make economic use of the slate and our mental capacity.

子类化发生新对象

内置对象是内置在python中的. 当我们动启python的时候就存在,常通程序结束的时候他们还存在.那我们怎样创立新对象呢?

新对象不会有生中无的涌现. 它们必须通过现有的对象来创立.

Example 2.4. 通过子类化构建对象

# Python 2.x:
class C(object): 1
    pass

# Python 3.x, 肯定的object类基已不要需指定了, 认默创立的都是class的类基:
class C: 2
    pass

class D(object):
    pass

class E(C, D): 3
    pass

class MyList(list): 4
    pass

1 关键字class诉告python通过子类化已有类型来创立一个新类型.
2 不要在Python 2.x中这样写，这样到得的是一个新式的类old-style class, 这里讲的这些在新式类里都是用不适的.
3 可以有多个类基.
4 数多内置类型都可以被子类化(但不是部全).

从下面的例子可知, C.bases 含包 <type 'object'>, 而 MyList.bases 含包 <type 'list'>.

例实化发生新对象

子类化只是发生对象的一种式方，还有另外一种.

Example 2.5. 通过例实化构建对象

obj = object() 1
cobj = C() 2
mylist = [1,2,3] 3

1 2 用调操纵符 (()) 通过例实化已有对象来创立新对象. 这里的已有对象必须是一个类对象type. 对于不同的类对象，这个用调操纵符可能接受数参.
2 对某些内置类型python有殊特的语法来创立新对象. 方括号创立 <type 'list'>的例实; 形整数字直接量创立一个 <type 'int'>对象.

有了下面习练的这些, 我们的对象图就看起来更完美了.

Figure 2.3. 用户定义对象

注意，仅仅通过子类化 <type 'object'>, 类型C 动自成为 <type 'type'>的例实. 可以通过看查C.class来认确这一点. 下节再对此做解释.

其实都是例实化的

对于这一点你可能会冒出下面这些问题，也可能没有，不过我还是算打解答一下:

Q: python是如何真正创立一个对象的?
A: python部内，当创立对象时, 肯定会用使一个type来创立这个type对象的一个例实. 体具的情况是用调这个类对象的new() 和 init() 方法(对这些容内的探讨已操纵本书范围). 某种义意上，可以将类对象（type）看作是可以出产新对象的工厂. 这些出产出来的对象的类型（type）将是创立他们的类对象（type）. 这就是为什么每个对象都有个类型type的原因.
Q: 当例实化的时候我们指定了类型，但子类化的时候，python如果肯定用使什么类型呢？
A: 这要看你子类化时指定的类基，将类基的类型type作为新对象（新类）的type,在 Example 2.4, “通过子类化构建对象”这个例子中 , <type 'type'> (指定的类基<type 'object'>的type) 被用做正在创立的C的类型.

想一下就会晓得数多iqngk下, <type 'object'>的任何子类 (以及子类的子类，等等)都将被付与<type 'type'>这个类型.

级高料材望展

一些更级高的探讨, 请仔细读阅, 或者跳到下一节.
Advanced discussion ahead, tread with caution, or jump straight to the next section.

Q: 我可以指定一个type来代替统系认默的机制吗?
A: 是的，一个可选方案就是用 metaclass 这个类的属性，如下示例:

Example 2.6. 用使class关键字定义类时指定一个type对象

   1 class MyCWithSpecialType(object):
   2     __metaclass__ = SpecialType

这样Python在创立MyCWithSpecialType时，是例实化 SpecialType的, 而不是<type 'type'>.
Q: 太棒了，可以把意任type对象作为metaclass?
A: 不是的，指定的元类metaclass必须是所用的类基的type的子类No. It must be a subclass of the type of the base object. 比如下面的例子中:
- MyCWithSpecialType 的类基是<type 'object'>.
- <type 'object'>的 type是<type 'type'>.
- 所以如果用SpecialType做 metaclass的话， SpecialType必须是 <type 'type'>的子类才行.
- 用使像SpecialType这样的货色要需别特心小，这些已出超本书的范围.
- （译注，
```
仿佛不是很切确，下面这个例子能行运。也多是我恰好选了个特例吧。
```
```
class Atype(type):
    pass
class AClass(object):
    __metaclass__ = Atype
class BClass(AClass):
    __metaclass__ = type
```
  - 不过这个特性实确日用常的多不，用不究深了，作者也说出超本书范围，如有求需再 google吧。)
- 实测某些情况下，有个元类突冲错误the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases）
Q: 如果有多个类基，但没指定metaclass，会用使哪个type对象呢?
A: 好问题. 取决于python否能计算出用哪个。若所以类基有雷同的type, 就是用这个. 若他们有不同的互不相干的type, python法无算出用哪个. 此时就要需指定一个metaclass, 并且这个metaclass 必须是每个类基的type的同共子类.
Q: 我什么时候该应用metaclass?
A: 永久别用 (只要你还问这个问题的话就别用

3. 总结一下

Python对象图

最后一章，我们终究到得一个有各种不同python对象的图

Figure 3.1. Python对象图

这一节我们也将解释图中灰色的竖线是干啥的. 根据人们对不同对象的叫法，灰色竖线将对象图成分三个区域 - 元类，类和例实.

察观这个图可以得出一些学究式的论结

虚线穿过了区域边界 (比如，从对象到元对象). 一唯的特例是<type 'type'> (也只能这样了, 否则就要需在它的左边再分一个另一个区域，另一个区域左边还得一个区域等等无穷尽。因为type的type就是自己啊).
线实不穿过边界. 又有一个外例, <type 'type'> -> <type 'object'> .
最边右的区域不能有线实. 它们是体具的对象，不能子类化.
虚线的箭头不能指向最边右区域. 体具的对象不能再例实化.
左边两个区域含包的是 types. 最边右区域含包的是non-types.
如果通过子类化<type 'type'>创立一个对象，它该应放在最左边的区域。并且它既是<type 'type'>的例实也是<type 'type'>的子类。

Also note that <type 'type'> is indeed a type of all types, and <type 'object'> a superclass of all types (except itself).

也要住记，<type 'type'>实确是有所类对象的type，而<type 'object'> 是有所类对象的类超（除了它自己）。

提要

总结一下谈到过的容内：

python中有两种对象:
1. - 可创立例实，可子类化.
2. Non-type objects - 不能创立例实，不能子类化.
<type 'type'>;<type 'object'> 是python统系中的两个基本对象.
每个对象都有class，并且即是该对象的type.
每个type object有bases属性，指向该对象的类超.只有<type 'object'>的bases是空的.
要通过子类化构建对象,我们用使class关键字，并指定新对象的类基bases (或者可选的 type) . 这样常通创立出的是type object.
要通过例实化构建对象, 要需用使在类对象上用使用调操纵符即小括号 (())
某些non-type objects可以用特定的python语法创立.比如[1, 2, 3] 创立一个 <type 'list'>的例实.
python在部内是总用使一个type object来创立一个新对象。创立出来的新对象是所用的type object的例实。通过class关键字创立的type object的类型的肯定要看所指定的bases以及bases们的类型。
issubclass(A,B) (测试类超-子类关系) ，以下情况回返True:
1. B在A.bases中，
2. 对于A.bases中的每个Z，如果 issubclass(Z,B)为True.（即若A的每个直接类基都是B的子类的话，就可以推导出 A也是B的子类）
isinstance(A,B) (测试类型-例实关系) ，以下情况回返True:
1. BBA.class,
2. issubclass(A.class,B) 为True.（即若A的类型是B的子类的话，A也就是B的例实）
这样看来，我的Squasher实确也是蟒蛇. (没提过，不过当初你就晓得了.)

很多多少内置类型还有个名字

Example 3.1. 更多内置 types

>>> import types  1

>>> types.ListType is list 2
True
>>> def f(): 3
...     pass
...
>>> f.__class__ is types.FunctionType 4
True
>>>
>>> class MyList(list): 5
...     pass
...
>>> class MyFunction(types.FunctionType): 6
...     pass
...
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: type 'function' is not an acceptable base type
>>> dir(types) 7
['BooleanType', 'DictProxyType', 'DictType', ..]

1 types 模块中含包很多内置类型.
2 一些我们熟知的类型还有另外一个名字.
3 def 创立一个function对象.
4 function对象的类型是 types.FunctionType
5 有的内置类型可以被子类化.
6 但另一些行不.
7 还有更多我们没解了过的类型.

这些有什么义意

我们可以用我们择选的对象间的关系来创立新对象,但这对我们有什么用？

对象间的关系决议了对象属性的拜访是怎么起作用的，例如，当用使objectname.attributename，我们到得哪个对象？这完整取决于该对象objectname，它的类型以及它的类基（如果有的话）。

python中的属性拜访机制在本系列的第二本书中解讲：Python Attributes and Methods.

经典类型Classic Classes

这是一份关于python中的classic classes 的备忘录. 用一个空的class关键字可以创立老式（早于python2.2）的类.

>>> class ClassicClass: 1
...     pass
...
>>> type(ClassicClass) 2
<type 'classobj'>
>>> import types
>>> types.ClassType is type(ClassicClass) 3
True
>>> types.ClassType.__class__ 4
<type 'type'>
>>> types.ClassType.__bases__ 5
(<type 'object'>,)

1 不指定类基的class关键字会创立老式的类，注意要创立新式的类必须指定对象作为类基(然而python3.0中不再要需指定类基，因为3.0中认默的就是新式类）。指定的类基中若只有老式类，那么创立出的也是老式类。若类基中老式的和新式的类都有的话创立出的就是新式的类。
2 这个类型本书中还没有看到过.
3 老式类的类型是一个叫types.ClassType 的对象.
4 5 看起来它也像是另外一类种对象.

types.ClassType这个对象某种程度上可代替<type 'type'>. 该对象的例实(即老式类) 该对象的例实 (老式类) 也是类对象types. 新老式对象之间的属性拜访规矩是不同的。 types.ClassType 这个对象的存在时为了向后兼容，在来将本版的python中可能就没有了. 本书的其他部份所讲的容内应不被套用到老式类上去。去。

请在这里评论: discussion page. 感激反馈!

到处结束了，朋友们!

4. 可能在其他地方学过的

面向对象

可以略过的章节？Can Skim Section

(注：这一节英文可能看着更舒畅，翻译起来很费力，感到有些术语翻译了就变味了，尽量看原文吧)

用怪古的一节来解讲类型-例实和类超-子类关系

我们引入很多不同的对象，他们之间只用两种关系就可以括概 ( 4.1. 关系)

“是一类” (图中线实): 即面向对象中的殊特化, 当其中一个(即子类)是另一个(类超)的殊特情况时两对象间存在这类关系.蛇“是一种”爬虫. 它有具爬虫的有所特征并且也有自己作为蛇的一些特独的特征.

术语: *的子类, *的类超 and 类超-子类.

“是一个例实子”(图中虚线): 也叫例实化, 当其中一个 (即例实)是另一个（即类型）的体具例子时两对象间存在这类关系. 我有一个宠物蛇叫Squasher. Squasher 是蛇的一个例实.

术语: *的例实, *的类型, 类型-例实或类-例实.

注意在简略英语中术语，以上两种关系都可以叫'是一个' . ，蛇是一个爬虫. 不过我们用特定的术语来防止淆混.

Figure 4.1. 关系

我们用线实表现第一种关系是因为对象之间很亲近而不是一个和另一个有关系。例如，如果让列出和“蛇”最类似的词，人们能可很会说“爬虫”。但如果让列出和 'Squasher'最类似的词，人们不大可能说“蛇”
We use the solid line for the first relationship because these objects are closer to each other than ones related by the second. To illustrate - if one is asked to list words similar to 'snake', one is likely to come up with 'reptile'. However, when asked to list words similar to 'Squasher', one is unlikely to say 'snake'.
基于这点，可以注意到下面的关系的属性
It is useful at this point to note the following (independent) properties of relationships:

如果X是A的例实,A是B的子类，则X也是B的例实.

如果B是M的例实，A是B的子类，则A也是M的例实.

换句话说, 虚线箭头一端可以向上移到线实箭头,虚线箭尾可以向下移 ( 如Figure 4.2. ""关系的递传" 中的2a和2b各自表现的).这些质性可以直接从类父-子类的关系定义到得

Figure 4.2. 关系的递传

用应虚线向上规矩, 可以从下面第一条描述到得第二条:

Squasher 是蛇的例实 (Squasher的类型是蛇).
Squasher 是爬虫的例实 (Squasher的类型是爬虫).

之前我们说过每个对象有一个切确的类型.为啥 Squasher有两个? 注意虽然每个说法都是精确的, 其中一个更切确 (切确的说可以演绎另一个).也可以说:

Squasher.class 是 snake. (Python中, 对象的class指向对象的type).
isinstance(Squasher, snake) 和isinstance(Squasher, reptile) 都精确.

类父-子类关系也有个类似的规矩.

并合线实规矩

若A是B的子类, B是C的子类, 则A也是C的子类

蛇是一种爬虫, 爬虫是一种物动. 有所蛇也是一种物动. 或者用Python代码表现:

snake.bases 是 (reptile,). (对象的bases 属性是一个含包对象类超的元组).
issubclass(snake, reptile) 和 issubclass(snake, animal) 都精确.

注意对象可能有不止一个类基.

相干料资

[descrintro] Unifying types and classes in Python 2.2 Guido van Rossum.
[pep-253] Subclassing Built-in Types Guido van Rossum.

版权息信

This book was written in DocBook XML. The HTML version was produced using DocBook XSL stylesheets and xsltproc. The PDF version was produced using htmldoc. The diagrams were drawn using OmniGraffe [1]. The process was automated using Paver [2].

Feedback

请点击这里评论: discussion page 待期反馈!

文章结束给大家分享下程序员的一些笑话语录：大家喝的是啤酒，这时你入座了。
你给自己倒了杯可乐，这叫低配置。
你给自已倒了杯啤酒，这叫标准配置。
你给自己倒了杯茶水，这茶的颜色还跟啤酒一样，这叫木马。
你给自己倒了杯可乐，还滴了几滴醋，不仅颜色跟啤酒一样，而且不冒热气还有泡泡，这叫超级木马。
你的同事给你倒了杯白酒，这叫推荐配置。
菜过三巡，你就不跟他们客气了。
你向对面的人敬酒，这叫p2p。
你向对面的人敬酒，他回敬你，你又再敬他……，这叫tcp。
你向一桌人挨个敬酒，这叫令牌环。
你说只要是兄弟就干了这杯，这叫广播。
有一个人过来向这桌敬酒，你说不行你先过了我这关，这叫防火墙。
你的小弟们过来敬你酒，这叫一对多。
你是boss，所有人过来敬你酒，这叫服务器。
酒是一样的，可是喝酒的人是不同的。
你越喝脸越红，这叫频繁分配释放资源。
你越喝脸越白，这叫资源不释放。
你已经醉了，却说我还能喝，叫做资源额度不足。
你明明能喝，却说我已经醉了，叫做资源保留。
喝酒喝到最后的结果都一样
你突然跑向厕所，这叫捕获异常。
你在厕所吐了，反而觉得状态不错，这叫清空内存。
你在台面上吐了，觉得很惭愧，这叫程序异常。
你在boss面前吐了，觉得很害怕，这叫系统崩溃。
你吐到了boss身上，只能索性晕倒了，这叫硬件休克。

分享到：

尾部、方法-Python和数据结构学习 -by小雨 | 方法、属性-Python属性和方法 -by小雨

2013-04-17 14:40
浏览 401
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论