• 可用type(a)查看对象a的类型
• 用isinstance(a,int)查看对象a是否指定类型。

大部分Python对象是可变的（mutable），如列表（list）、字典（dict）、Numpy数组以及大部分用户自定义类型；字符串（string）和元组（tuple） 是不可变的。

1. 列表（list）

（1） 列表的定义

列表是一个数据集合，动态的，可以随需要伸缩，数据使用的所有内存都由python管理。通过方括号（[]）或list()函数定义。

e.g.

a_list=[2,3,7,None]
tup=('foo','bar','baz')
b_list=list(tup)

（2）列表的切片

访问列表的多个数据可以使用切片，如a_list[0:3]
使用-1，可以实现列表（或元组的反序），如a_list[::-1]。

e.g.

a_list = ['a','b','c','h','e']
a_list[:2]

输出：

[‘a’, ‘b’]

a_list[0:5:2] #[start:end:step]

输出：

[‘a’, ‘c’, ‘e’]

a_list[::-1]

输出：

[‘e’, ‘h’, ‘c’, ‘b’, ‘a’]

（3）列表的方法

append() 将元素添加到列表末尾
insert() 将元素插入到列表指定位置
pop() 移除并返回指定索引处的元素
remove() 按值删除元素
sort() 排序
count() 列表中对象的计数

a_list = ['a','b','c','h','e']
a_list.append('a')
a_list

输出：

[‘a’, ‘b’, ‘c’, ‘h’, ‘e’, ‘a’]

a_list.count('a')

输出：

2

a_list.sort()
a_list

输出：

[‘a’, ‘a’, ‘b’, ‘c’, ‘e’, ‘h’]

2. 元组（tuple）

元组是一种一维的、定长的、不可变的Python对象序列。
最简单的创建方式是一组以逗号隔开的值。

对元组型变量表达式进行赋值，Python就会尝试将等号右侧的值进行拆包（unpacking）。

e.g.

my_tuple = (1,3,'a','hello')

3. 字典（dict）

（1） 字典的定义

字典是一种大小可变的键值对集，字典的值可以是任何Python对象，但键必须是不可变对象。

创建字典可使用{}或dict()工厂函数：
new_d={} 或 new_d=dict()

然后增加数据
d['name']='Eric Idle' 也可 new_d={'name':'Eric Idle'}

将两个序列中的元素两两配对地组成一个字典： maping=dict(zip(range(5),reversed(range(5))))

e.g.

#  dict([k1,v1],[k2,v2]...)
valList = ['a','b','c','d','e']
mapping=dict(zip(range(5),valList))
print(mapping)

输出：

{0: ‘a’, 1: ‘b’, 2: ‘c’, 3: ‘d’, 4: ‘e’}

（2）字典的方法

keys()和values() 分别用于获取键和值，分别返回字典中键和值的列表
d1.update(d2) 添加d2中所有项目到d1
list(d)字典的键的列表
sorted(d) 字典的键的列表，排序
key in d 测试特定的键是否在字典中
for key in d 遍历字典的键
dict([k1,v1],[k2,v2],...) 从一个键-值对列表创建一个字典

e.g.

for key in mapping:
    print(mapping[key])

输出：

a
b
c
d
e

4. 集合（set）

集合是由唯一元素组成的无序集，可以看做只有键没有值的字典。
创建集合可使用{}或set()工厂函数。

e.g.

a_list = ['a','b','c','h','e','a','e']
a_set = set(a_list)
b_set = {'a','b','c','h','e','a','e'}

集合支持交（&）、并（|）、差（-）、异或（^）的操作。

5. 字符串（string）

Python字符串是不可变的，可以使用单引号（‘）或双引号（"），对于带有换行符的多行字符串，可以使用三重引号（’''或"“”）。

反斜杠(\)是转义字符(escape character)，可用于指定特殊字符（如\n或unicode字符）。在字符串最左边引号前加上r，表示所有字符按照原样进行转义。

string对象的主要方法：
split() 将一个字符串分解为一个子串列表
find() 在一个字符串中查找一个特定字串
strip() 从字符串去除不需要的空白符
字符串是一串字符序列，可以被当做某种序列类型（如列表、元组等）进行处理。

可以把一个字符串赋值给一个变量，索引一个字符串，切片一个字符串。

e.g.

name = 'Monty'
name[0]

输出：

‘M’

name[:4]

输出：

‘Mont’

name = '.'.join(['Monty','Python'])
name

输出：

‘Monty.Python’

name.split('.')

输出：

[‘Monty’, ‘Python’]

name.find('Python')

输出：

6

name.find('on') 

输出：

1

name.find('Monpy')

输出：

-1

6. BIF （Built-in Function）

str() 用来访问任何数据对象（支持串转换）的串表示。
isinstance() 检查一个标识符是否指示某个指定类型的数据对象。
range() 与for结合使用，迭代固定次数。
sorted() 将任何序列返回一个新的有序列表，传入reverse=True可以按降序排列数据。sorted()和set()结合可以得到一个由序列中的唯一元素组成的有序列表。

enumerate()可以逐个返回序列的(i,value)元组。
for item in s 遍历s中的元素
for item in sorted(s) 按顺序遍历s中的元素
for item in reversed(s) 按逆序遍历s中的元素
for item in set(s) 遍历s中无重复的元素
for item in set(s).difference(t) 遍历在集合s中不在t的元素
for item in random.shuffle(s) 随机遍历s中的元素

zip()用于将多个序列（列表、元组）中的元素配对，从而产生一个新的元组列表。zip()可以接受任意数量的序列，最终得到的元组数量由最短的序列决定。

e.g.

seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
zip(seq1,seq2)
for i,(a,b) in enumerate(zip(seq1,seq2)):
    print('%d:%s,%s' %(i,a,b))

输出：

0:foo,one
1:bar,two
2:baz,three

对于“已压缩的”（zipped）序列，zip()可对该序列进行“解压”（unzip）。

e.g.

pitchers = [('Nolan','Ryan'),('Roger','Clemens'),('Schilling','Curt')]
first_names,last_names = zip(*pitchers)
print(first_names, last_names)

输出：

(‘Nolan’, ‘Roger’, ‘Schilling’) (‘Ryan’, ‘Clemens’, ‘Curt’)

7. 列表、集合以及字典的推导式

new_l = []
for t in old_l:
  new_l.append(len(t))

列表推导(函数编程)：
new_l = [len(t) for t in old_l]

e.g.

strings = ['a','as','bat','car','car','dove','python']
[s.upper() for s in strings if len(s)>2]

输出：

[‘BAT’, ‘CAR’, ‘CAR’, ‘DOVE’, ‘PYTHON’]

{s.upper() for s in strings if len(s)>2}

输出：

{‘BAT’, ‘CAR’, ‘DOVE’, ‘PYTHON’}

{index:val for index,val in enumerate(strings)}

输出：

{0: ‘a’, 1: ‘as’, 2: ‘bat’, 3: ‘car’, 4: ‘car’, 5: ‘dove’, 6: ‘python’}

dict((index,val) for index,val in enumerate(strings))

输出：

{0: ‘a’, 1: ‘as’, 2: ‘bat’, 3: ‘car’, 4: ‘car’, 5: ‘dove’, 6: ‘python’}