1. Python对象

所有的Python对象都拥有三个特性:身份,类型和值.

身份: 每一个对象都有一个唯一的身份标识自己,任何对象的身份可以使用内建函数id()来得到.这个值可以被认为是该对象的内存地址.

类型: 对象的类型决定了该对象可以保存什么类型的值,可以进行什么样的操作,以及遵循什么样的规则.我们可以使用type()查看Python对象的类型.

值: 对象表示的数据项.

1. type在函数中起判断作用

我们定义一个函数,要求传递的参数必须是元组(因为元组不可更改),则我们可以这样判断(可以引申到判断参数为整数,浮点数,字典等等):

>>> def func(aTuple):if type(aTuple) != tuple:print 'not tuple'else:print 'tuple'>>> func([1, 2, 3])
not tuple
>>> func((1, 2, 3))
tuple

2. is/is not, isinstance操作符

A is B: A和B是同一个对象

A is not B: A和B不是同一个对象

isinstance(A, (int, long, float, complex)): A的类型是否为(int, long, float, complex),也适用于类实例的判断

3. 内建类型,引用类型的区别

内建类型: 整型,字符串,元组

引用类型:列表,字典,类对象

对内建类型的赋值,实际上是销毁原对象,新建一个对象:

>>> ss = 'hello world'
>>> id(ss)
46651264L
>>> ss = 'what'
>>> id(ss)
34271280L

而引用类型则保持不变:

>>> arr = [1, 2, 3]
>>> id(arr)
45887240L
>>> arr.append(4)
>>> id(arr)
45887240L

4. 标准类型的分类

以存储模型为标准的类型分类:

标量/原子类型(保持单个字面对象的类型): 数值(所有的数值类型),字符串

容器类型(容纳多个相同/不同对象的类型): 列表,元组,字典

以更新模型为标准的类型分类:

可变类型: 列表,字典

不可变类型: 数字,字符串,元组

以访问模型为标准的类型分类:

直接访问: 数字

顺序访问: 字符串,列表,元组

映射访问: 字典

2. 序列:字符串,列表和元组

1. 通用函数

额外知识：浅拷贝和深拷贝

浅拷贝只是拷贝对象的索引，而不是重新建立了一个对象。如果完全拷贝一个对象，则需要深拷贝：

In [22]: arr
Out[22]: [1, 2, 3, [4, 5]]In [23]: Tuple1 = tuple(arr)In [24]: import copyIn [25]: Tuple2 = copy.deepcopy(tuple(arr))In [26]: [id(x) for x in arr]
Out[26]: [42791256, 42791232, 42791208, 140595426198232]In [27]: [id(x) for x in Tuple1]
Out[27]: [42791256, 42791232, 42791208, 140595426198232]In [28]: [id(x) for x in Tuple2]
Out[28]: [42791256, 42791232, 42791208, 140595427957864]

这里arr和Tuple1的元素id全部一样（由于整形1,2,3是不可改变，所以重新赋值会新建一个对象），而Tuple2的[4, 5]的id不一样，说明进行了深拷贝。

list(iter): 把可迭代对象转换为列表。

str(obj): 把obj对象转换成字符串

tuple(iter): 把一个可迭代对象转换成一个元组对象

enumerate(iter): 接受一个可迭代对象作为参数，返回一个enumerate对象（同时也是一个迭代器），该对象生成由iter每个元素的index值和item值组成的元组。

len(seq): 返回seq的长度

max/min(iter, key = None):返回最大值，指定key则必须是一个可以传给sort()方法的，用于比较的回调函数。

reversed(seq): 接受一个序列作为参数，返回一个以逆序访问的迭代器。

sorted(iter, func = None, key = None, reverse = False): 接受一个可迭代对象作为参数，返回一个有序的列表。

sum(seq, init = 0): 返回seq和可选参数init的总和，其效果等同于reduce(operator.add, seq, init)

zip([it0, it1, it2]):举例说明

In [29]: iter1 = (1, 2, 3)In [30]: iter2 = [11, 12, 13]In [31]: iter3 = [21, 22, 23]In [32]: zip(iter1, iter2, iter3)
Out[32]: [(1, 11, 21), (2, 12, 22), (3, 13, 23)]

3. 映射

1. 哈希表

哈希表是一种数据结构，哈希表中存储的每一条数据，叫做一个值，是根据与它相关的一个被称作键的数据项进行存储的。键和值合在一起被称为“键-值”对。哈希表的算法是活取键，对键执行一个叫做哈希函数的操作，并根据计算的结果，选择在数据结构的某个地址中来存储你的值。任何一个值存储的地址皆取决于它的键。正因为这种随意性，哈希表中的值是没有顺序的。你拥有的是一个无序的数据集。

你所能获得的有序集合只能是字典中的键的集合或者值的集合。方法Keys()或values()返回一个列表，该列表是可排序的。你还可以用item()方法得到包含键，值对的元组的列表来排序。由于字典本身是哈希的，所以是无序的。

哈希表一般有很好的性能，因为用键查询相当快。

2. 字典的键必须是可哈希的

因为我们需要通过键来查找数据，所以键必须保持不变，即键必须是可哈希的（通过hash判断）：

In [45]: dst = {}In [46]: dst[[1, 2]] = 3
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-46-70dfcbeb49dc> in <module>()
----> 1 dst[[1, 2]] = 3TypeError: unhashable type: 'list'In [47]: hash([1, 2])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-47-0e7c08465b16> in <module>()
----> 1 hash([1, 2])TypeError: unhashable type: 'list'

3. 映射相关函数

dict()： 工厂函数，用来创建字典，参数为可迭代对象。

len()： 返回字典的长度

hash()： 判断对象是否可哈希，返回其哈希值。

in/ not in: 判断键是否在字典中

映射类型的内建方法：

keys(), values(), items()： 返回字典的键，值，键-值对

clear()： 删除字典中所有元素

copy(): 返回字典的一个副本（浅复制）

fromkeys(seq, val = None): 创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值。

get(key, default = None): 获取键key对应的值，如果不存在则返回默认值default.

pop(key, [, default])： key存在，则删除并返回dict[key]，否则返回default。如果key不存在也不提供default，则引发KeyError异常。

setdefault(key, default = None): 如果字典中不存在key键，则用default赋值。

4. 迭代器，列表解析和生成器

1. 迭代器

从根本上说，迭代器就是有一个next()方法的对象，而不是通过索引来计数，全部迭代完会引发一个StopIteration异常。

我们一般可以迭代序列，字典和文件：

In [56]: arr = [1, 2]In [57]: i = iter(arr)In [58]: i.next()
Out[58]: 1In [59]: i.next()
Out[59]: 2In [60]: i.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-60-e590fe0d22f8> in <module>()
----> 1 i.next()StopIteration:

而迭代器实际上等价于for循环：

for i in seq:do_something_to(i)

<==>

fetch = iter(seq)while True:try:i = fetch.next()except StopIteration:breakdo_something_to(i)

2. 列表解析

语法如下：

[expr for iter_var in iterable if cond_expr]

实例如下：

In [61]: [x for x in range(6) if x % 2]
Out[61]: [1, 3, 5]

3. 生成器表达式

语法如下：

(expr for iter_var in iterable if cond_expr)

列表解析的一个不足就是必要生成所有的数据。但是生成器表达式是返回一个生成器，每次计算出一个条目后，把这个条目yield出来，采用了延迟计算。

In [63]: lst = (x for x in range(6) if x % 2)In [64]: lst
Out[64]: <generator object <genexpr> at 0x7fdeec558320>In [65]: for i in lst:....:     print i,....:
1 3 5

<==>

In [67]: def fun(arr):....:     for i in arr:....:         yield i....:         In [68]: arr = [1, 2, 3]In [71]: for i in fun(arr):....:     print i,....:
1 2 3