前两章里面包含的字符串、布尔类型、整数、浮点数都是数据类型。数据类型在一个编程语言中必不可少，也是使用最多的。

而且数据类型的数据都是存放在内存中的，我们一般操作都是在对内存里对象操作。

什么是数组？

数组也是一种数据类型，为了方便处理数据，把一些同类数据放到一起就是数组，是一组数据的集合，数组内的数据称为元素，每个元素都有一个下标（索引），从0开始。

在Python中，内建数据结构有列表（list）、元组（tuple）、字典（dict）、集合（set）。

3.1 列表[List]

3.1.1 定义列表

1
>>> lst  =  [ 'a' , 'b' , 'c' , 1 , 2 , 3 ]

用中括号括起来，元素以逗号分隔，字符串用单引号引起来，整数不用。

列表常用方法：  

wKiom1fUtNvR7804AABX1we14JM806.png-wh_50

3.1.2 基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 追加一个元素    
>>> lst.append( 4 )
>>> lst
[ 'a' ,  'b' ,  'c' ,  1 ,  2 ,  3 ,  4 ]
# 统计列表中a字符出现的次数
>>> lst.count( 'a' )
1
# 将一个列表作为元素添加到lst列表中
>>> a  =  [ 5 , 6 ]
>>> lst.extend(a)
>>> lst
[ 'a' ,  'b' ,  'c' ,  1 ,  2 ,  3 ,  4 ,  5 ,  6 ]
# 查找元素3的索引位置
>>> lst.index( 1 )
3
# 在第3个索引位置插入一个元素
>>> lst.insert( 3 ,  0 )
>>> lst
[ 'a' ,  'b' ,  'c' ,  0 ,  1 ,  2 ,  3 ,  4 ,  5 ,  6 ]
# 删除最后一个元素和第3个下标元素
>>> lst.pop()  
6
>>> lst.pop( 3 )
0
>>> lst
[ 'a' ,  'b' ,  'c' ,  1 ,  2 ,  3 ,  4 ,  5 ]
# 删除元素是5，如果没有会返回错误
>>> lst.remove( "5" )
>>> lst
[ 'a' ,  'b' ,  'c' ,  1 ,  2 ,  3 ,  4 ]
# 倒序排列元素
>>> lst.reverse()
>>> lst
[ 4 ,  3 ,  2 ,  1 ,  'c' ,  'b' ,  'a' ]
# 正向排序元素
>>> lst.sort()
>>> lst
[ 1 ,  2 ,  3 ,  4 ,  'a' ,  'b' ,  'c' ]
# 列表连接
>>> a  =  [ 1 , 2 , 3 ]
>>> b  =  [ 'a' , 'b' , 'c' ]
>>> a  +  b
[ 1 ,  2 ,  3 ,  'a' ,  'b' ,  'c' ]

3.1.3 学习新函数对列表排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# reversed()函数倒序排列    
使用此函数会创建一个迭代器，遍历打印才能输出：
>>> lst  =  [ 'a' ,  'b' ,  'c' ,  1 ,  2 ,  3 ,  4 ,  5 ]
>>>  type ( reversed (lst))
< type  'listreverseiterator' >
>>> lst2  =  []
>>>  for  i  in  reversed (lst):
...   lst2.append(i)
...
>>> lst2
[ 5 ,  4 ,  3 ,  2 ,  1 ,  'c' ,  'b' ,  'a' ]
# sorted()函数正向排列
>>> lst2  =  []
>>>  for  i  in  sorted (lst):
...   lst2.append(i)
...
>>> lst2
[ 1 ,  2 ,  3 ,  4 ,  5 ,  'a' ,  'b' ,  'c' ]
这里在讲解一个序列生成器 range ()函数,生成的是一个列表：
>>>  type ( range ( 5 ))
< type  'list' >
>>>  for  i  in  range ( 1 , 5 ):
...    print  i
...
1
2
3
4
当然也可以用上面的排序函数来排序这个生成的序列了：
>>>  for  i  in  reversed ( range ( 1 , 10 , 3 )):
...    print  i
...
7
4
1

range()用法：range(start,end,step)

说明：是不是和列表内置方法结果一样！区别是内置函数不改动原有序列。

3.1.4 切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
>>> lst    
[ 1 ,  2 ,  3 ,  4 ,  'a' ,  'b' ,  'c' ]
# 返回第一个元素
>>> lst[ 0 ]
1
# 返回倒数第一个元素
>>> lst[ - 1 ]
'c'
# 取出倒数第一个元素
>>> lst[ 0 : - 1 ]
[ 1 ,  2 ,  3 ,  4 ,  'a' ,  'b' ]
# 返回第一个至第四个元素
>>> lst[ 0 : 4 ]
[ 1 ,  2 ,  3 ,  4 ]
3.1 . 5  清空列表
方法 1 ：
>>> lst  =  [ 1 ,  2 ,  3 ,  4 ,  'a' ,  'b' ,  'c' ]
>>> lst  =  []
>>> lst
[]
方法 2 ：
>>> lst  =  [ 1 ,  2 ,  3 ,  4 ,  'a' ,  'b' ,  'c' ]
>>>  del  lst[:]
>>> lst
[]
# 删除列表
>>> lst  =  [ 1 ,  2 ,  3 ,  4 ,  'a' ,  'b' ,  'c' ]
>>>  del  lst
>>> lst
Traceback (most recent call last):
   File  "<stdin>" , line  1 ,  in  <module>
NameError: name  'lst'  is  not  defined

3.1.6 del语句

del语句也可以删除一个下标范围的元素

1
2
3
4
>>> lst  =  [ 1 ,  2 ,  3 ,  4 ,  'a' ,  'b' ,  'c' ]    
>>>  del  lst[ 0 : 4 ]
>>> lst
[ 'a' ,  'b' ,  'c' ]

3.1.7 列表推导式

利用其它列表推导出新的列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 通过迭代对象方法    
方法 1 ：
>>> lst  =  []
>>>  for  i  in  range ( 5 ):
...   lst.append(i)
...
>>> lst
[ 0 ,  1 ,  2 ,  3 ,  4 ]
方法 2 ：
>>> lst  =  []
>>> lst  =  [i  for  i  in  range ( 5 )]
>>> lst
[ 0 ,  1 ,  2 ,  3 ,  4 ]
说明：方法 1 和方法 2 ，实现方式是一样的，只是方法 2 用简洁的写法。 for 循环在下一章会讲。
     
# 通过已有的列表生成新列表
>>> lst
[ 0 ,  1 ,  2 ,  3 ,  4 ]
>>> lst2  =  [i  for  i  in  lst  if  i >  2 ]
>>> lst2
[ 3 ,  4 ]

3.1.8 遍历列表

如果既要遍历索引又要遍历元素，可以这样写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
方法 1 ：    
>>> lst  =  [ 'a' , 'b' , 'c' , 1 , 2 , 3 ]
>>>  for  i  in  range ( len (lst)):
...    print  i,lst[i]         
...
0  a
1  b
2  c
3  1
4  2
5  3
方法 2 ：
>>>  for  index, value  in  enumerate (lst):
...    print  index,value
...
0  a
1  b
2  c
3  1
4  2
5  3

又学了一个新函数enumrate()，可遍历列表、字符串的下标和元素。

3.2 元组(Tuple)

元组与列表类型，不同之处在于元素的元素不可修改。

2.1 定义元组

1
t  =  ( 'a' , 'b' , 'c' , 1 , 2 , 3 )

用小括号括起来，元素以逗号分隔，字符串用单引号引起来，整数不用。

wKioL1fUwuuDMFVzAAA7zcv9bNo309.png-wh_50  spacer.gif    

2.2 基本操作

count()和index()方法和切片使用方法与列表使用一样，这里不再讲解。

3.3 集合(set)

集合是一个无序不重复元素的序列，主要功能用于删除重复元素和关系测试。

集合对象还支持联合（union），交集（intersection），差集（difference）和对称差集（sysmmetric difference）数学运算。

需要注意的是，集合对象不支持索引，因此不可以被切片。

3.3.1 定义集合

1
2
3
4
# 创建个空集合
>>> s  =  set ()
>>> s
set ([])

使用set()函数创建集合。  

wKiom1fUwxSxY3V-AAB4qhZ4fuk549.png-wh_50  spacer.gif

3.3.2 基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 添加元素    
>>> s.add( 'a' )
>>> s
set ([ 'a' ])
>>> s.add( 'b' )
>>> s
set ([ 'a' ,  'b' ])
>>> s.add( 'c' )
>>> s
set ([ 'a' ,  'c' ,  'b' ])
>>> s.add( 'c' )
>>> s
set ([ 'a' ,  'c' ,  'b' ])
说明：可以看到，添加的元素是无序的，并且不重复的。
# update方法事把传入的元素拆分为个体传入到集合中。与直接set('1234')效果一样。
>>> s.update( '1234' )
>>> s
set ([ 'a' ,  'c' ,  'b' ,  '1' ,  '3' ,  '2' ,  '4' ])
# 删除元素
>>> s.remove( '4' )   
>>> s
set ([ 'a' ,  'c' ,  'b' ,  '1' ,  '3' ,  '2' ])
# 删除元素，没有也不会报错，而remove会报错
>>> s.discard( '4' )   
>>> s
set ([ 'a' ,  'c' ,  'b' ,  '1' ,  '3' ,  '2' ])
# 删除第一个元素
>>> s.pop()
'a'
>>> s
set ([ 'c' ,  'b' ,  '1' ,  '3' ,  '2' ])
# 清空元素
>>> s.clear()
>>> s
set ([])
# 列表转集合，同时去重
>>> lst  =  [ 'a' , 'b' , 'c' , 1 , 2 , 3 , 1 , 2 , 3 ]
>>> s  =  set (lst)
>>> s
set ([ 'a' ,  1 ,  'c' ,  'b' ,  2 ,  3 ])

3.3.3 关系测试

符号

描述

-

差集

&

交集

|

合集、并集

!=

不等于

==

等于

in

是成员为真

not in

不是成员为真

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
>>> a  =  set ([ 1 ,  2 ,  3 ,  4 ,  5 ,  6 ])
>>> b  =  set ([ 4 ,  5 ,  6 ,  7 ,  8 ,  9 ])
# 返回差集，a中有的b中没有的
>>> a  -  b
set ([ '1' ,  '3' ,  '2' ])
# b中有的a中没有的
>>> b  -  a
set ([ '9' ,  '8' ,  '7' ])
# 返回交集
>>> a & b
set ([ '5' ,  '4' ,  '6' ])
# 返回合集
>>> a | b
set ([ '1' ,  '3' ,  '2' ,  '5' ,  '4' ,  '7' ,  '6' ,  '9' ,  '8' ])
# 不等于
>>> a ! =  b
True
# 等于
>>> a  = =  b
False
# 存在为真
>>>  '1'  in  a
True
# 不存在为真
>>>  '7'  not  in  a
True


博客地址：http://lizhenliang.blog.51cto.com

QQ群：Shell/Python运维开发群 323779636


3.4 字典{Dict}

序列是以连续的整数位索引，与字典不同的是，字典以关键字为索引，关键字可以是任意不可变对象（不可修改），通常是字符串或数值。

字典是一个无序键:值（Key:Value）集合，在一字典中键必须是互不相同的，

wKiom1fUuALiu13hAABX1we14JM714.png-wh_50

3.4.1 定义字典

1
>>> d  =  { 'a' : 1 ,  'b' : 2 ,  'c' : 3 }

用大括号括起来，一个键对应一个值，冒号分隔，多个键值逗号分隔。

3.4.2 基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# 返回所有键值
>>> d.items()
[( 'a' ,  1 ), ( 'c' ,  3 ), ( 'b' ,  2 )]
# 返回所有键
>>> d.keys()
[ 'a' ,  'c' ,  'b' ]
# 查看所有值
>>> d.values()
[ 1 ,  3 ,  2 ]
# 添加键值
>>> d[ 'e' ]  =  4
>>> d
{ 'a' :  1 ,  'c' :  3 ,  'b' :  2 ,  'e' :  4 }
# 获取单个键的值,如果这个键不存在就会抛出KeyError错误
>>> d[ 'a' ]
>>>  1
# 获取单个键的值,如果有这个键就返回对应的值，否则返回自定义的值no
>>> d.get( 'a' , 'no' )
1
>>> d.get( 'f' , 'no' )
no
# 删除第一个键值
>>> d.popitem()
( 'a' ,  1 )
>>> d
{ 'c' :  3 ,  'b' :  2 ,  'e' :  4 }
# 删除指定键
>>> d.pop( 'b' )
2
>>> d
{ 'c' :  3 ,  'e' :  4 }
# 添加其他字典键值到本字典
>>> d
{ 'c' :  3 ,  'e' :  4 }
>>> d2  =  { 'a' : 1 }
>>> d.update(d2) 
>>> d
{ 'a' :  1 ,  'c' :  3 ,  'e' :  4 }
# 拷贝为一个新字典
>>> d
{ 'a' :  1 ,  'c' :  3 ,  'e' :  4 }
>>> dd  =  d.copy()
>>> dd
{ 'a' :  1 ,  'c' :  3 ,  'e' :  4 }
>>> d
{ 'a' :  1 ,  'c' :  3 ,  'e' :  4 }
# 判断键是否在字典
>>> d.has_key( 'a' )
True
>>> d.has_key( 'b' )
False

3.4.3 可迭代对象

字典提供了几个获取键值的迭代器，方便我们在写程序时处理，就是下面以iter开头的方法。

d.iteritems()  # 获取所有键值，很常用

d.iterkeys()   # 获取所有键

d.itervalues() # 获取所有值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 遍历iteritems()迭代器    
>>>  for  i  in  d.iteritems():
...    print  i
...
( 'a' ,  1 )
( 'c' ,  3 )
( 'b' ,  2 )
说明：以元组的形式打印出了键值
如果我们只想得到键或者值呢，就可以通过元组下标来分别获取键值：
>>>  for  i  in  d.iteritems():   
...    print  "%s:%s"  % (i[ 0 ],i[ 1 ])
...
a: 1
c: 3
b: 2
有比上面更好的方法实现：
>>>  for  k, v  in  d.iteritems():
...    print  "%s: %s"  % (k, v)   
...
a:  1
c:  3
b:  2
这样就可以很方面处理键值了！
# 遍历其他两个迭代器也是同样的方法
>>>  for  i  in  d.iterkeys():
...    print  i
...
a
c
b
>>>  for  i  in  d.itervalues():
...    print  i
...
1
3
2

说明：上面用到了for循环来遍历迭代器，for循环的用法在下一章会详细讲解。

3.4.4 一个键多个值

一个键对应一个值，有些情况无法满足需求，字典允许一个键多个值，也就是嵌入其他数组，包括字典本身。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 嵌入列表
>>> d  =  { 'a' :[ 1 , 2 , 3 ],  'b' : 2 ,  'c' : 3 }
>>> d[ 'a' ]    
[ 1 ,  2 ,  3 ]  
>>> d[ 'a' ][ 0 ]   # 获取值
1
>>> d[ 'a' ].append( 4 )   # 追加元素
>>> d
{ 'a' : [ 1 ,  2 ,  3 ,  4 ],  'c' :  3 ,  'b' :  2 }
# 嵌入元组
>>> d  =  { 'a' :( 1 , 2 , 3 ),  'b' : 2 ,  'c' : 3 }   
>>> d[ 'a' ][ 1 ]
2
# 嵌入字典
>>> d  =  { 'a' :{ 'd' : 4 , 'e' : 5 },  'b' : 2 ,  'c' : 3 }   
>>> d[ 'a' ]
{ 'e' :  5 ,  'd' :  4 }
>>> d[ 'a' ][ 'd' ]     # 获取值
4
>>> d[ 'a' ][ 'e' ]  =  6   # 修改值
>>> d
{ 'a' : { 'e' :  6 ,  'd' :  4 },  'c' :  3 ,  'b' :  2 }

3.5 额外的数据类型

colloctions()函数在内置数据类型基础上，又增加了几个额外的功能，替代内建的字典、列表、集合、元组及其他数据类型。

3.5.1 namedtuple

namedtuple函数功能是使用名字来访问元组元素。

语法：namedtuple("名称", [名字列表])

1
2
3
4
5
6
7
8
9
>>>  from  collections  import  namedtuple    
>>> nt  =  namedtuple( 'point' , [ 'a' ,  'b' ,  'c' ])
>>> p  =  nt( 1 , 2 , 3 )
>>> p.a
1
>>> p.b
2
>>> p.c
3

namedtuple函数规定了tuple元素的个数，并定义的名字个数与其对应。

3.5.2 deque

当list数据量大时，插入和删除元素会很慢，deque的作用就是为了快速实现插入和删除元素的双向列表。

1
2
3
4
5
6
7
8
9
10
11
12
>>>  from  collections  import  deque    
>>> q  =  deque([ 'a' ,  'b' ,  'c' ])
>>> q.append( 'd' )
>>> q
deque([ 'a' ,  'b' ,  'c' ,  'd' ])
>>> q.appendleft( 0 )
>>> q
deque([ 0 ,  'a' ,  'b' ,  'c' ,  'd' ])
>>> q.pop()
'd'
>>> q.popleft()
0

实现了插入和删除头部和尾部元素。比较适合做队列。

3.5.3 Counter

顾名思义，计数器，用来计数。

例如，统计字符出现的个数：

1
2
3
4
5
6
7
>>>  from  collections  import  Counter    
>>> c  =  Counter()
>>>  for  i  in  "Hello world!" :
...   c[i]  + =  1             
...
>>> c
Counter({ 'l' :  3 ,  'o' :  2 ,  '!' :  1 ,  ' ' :  1 ,  'e' :  1 ,  'd' :  1 ,  'H' :  1 ,  'r' :  1 ,  'w' :  1 })

结果是以字典的形式存储，实际Counter是dict的一个子类。

3.5.4 OrderedDict

内置dict是无序的，OrderedDict函数功能就是生成有序的字典。

例如，根据前后插入顺序排列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> d  =  { 'a' : 1 ,  'b' : 2 ,  'c' : 3 }    
>>> d    # 默认dict是无序的
{ 'a' :  1 ,  'c' :  3 ,  'b' :  2 }
>>>  from  collections  import  OrderedDict
>>> od  =  OrderedDict()
>>> od[ 'a' ]  =  1
>>> od[ 'b' ]  =  2
>>> od[ 'c' ]  =  3
>>> od
OrderedDict([( 'a' ,  1 ), ( 'b' ,  2 ), ( 'c' ,  3 )])
# 转为字典
>>>  import  json 
>>> json.dumps(od)
'{"a": 1, "b": 2, "c": 3}'

OrderedDict输出的结果是列表，元组为元素，如果想返回字典格式，可以通过json模块进行转化。

3.6 数据类型转换

3.6.1 常见数据类型转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
# 转整数    
>>> i  =  '1'
>>>  type (i)
< type  'str' >
>>>  type ( int (i))
< type  'int' >
# 转浮点数
>>> f  =  1
>>>  type (f)
< type  'int' >
>>>  type ( float (f))
< type  'float' >
# 转字符串
>>> i  =  1
>>>  type (i)
< type  'int' >
>>>  type ( int ( 1 ))
< type  'int' >
# 字符串转列表
方式 1 ：
>>> s  =  'abc'
>>> lst  =  list (s)
>>> lst
[ 'a' ,  'b' ,  'c' ]
方式 2 ：
>>> s  =  'abc 123'
>>> s.split()   
[ 'abc' ,  '123' ]
# 列表转字符串
>>> s  =  ""
>>> s  =  ''.join(lst)
>>> s
'abc'
# 元组转列表
>>> lst
[ 'a' ,  'b' ,  'c' ]
>>> t  =  tuple (lst)
>>> t
( 'a' ,  'b' ,  'c' )
# 列表转元组
>>> lst  =  list (t)
>>> lst
[ 'a' ,  'b' ,  'c' ]
# 字典格式字符串转字典
方法 1 ：
>>> s  =  '{"a": 1, "b": 2, "c": 3}'
>>>  type (s)
< type  'str' >
>>> d  =  eval (s)
>>> d
{ 'a' :  1 ,  'c' :  3 ,  'b' :  2 }
>>>  type (d)
< type  'dict' >
方法 2 ：
>>>  import  json
>>> s  =  '{"a": 1, "b": 2, "c": 3}'
>>> json.loads(s)
{u 'a' :  1 , u 'c' :  3 , u 'b' :  2 }
>>> d  =  json.loads(s)
>>> d
{u 'a' :  1 , u 'c' :  3 , u 'b' :  2 }
>>>  type (d)
< type  'dict' >

3.6.2 学习两个新内建函数

1) join()

join()函数是字符串操作函数，用于字符串连接。

1
2
3
4
5
6
7
8
9
10
11
12
13
# 字符串时，每个字符作为单个体        
>>> s  =  "ttt"
>>>  "." .join(s)
't.t.t'
# 以逗号连接元组元素，生成字符串，与上面的列表用法一样。
>>> t  =  ( 'a' ,  'b' ,  'c' )
>>> s  =  "," .join(t)
>>> s
'a,b,c'
# 字典
>>> d  =  { 'a' : 1 ,  'b' : 2 ,  'c' : 3 }
>>>  "," .join(d)
'a,c,b'

2) eval()

eval()函数将字符串当成Python表达式来处理。

1
2
3
4
5
6
7
8
>>> s  =  "abc"        
>>>  eval ( 's' )
'abc'
>>> a  =  1
>>>  eval ( 'a + 1' )
2
>>>  eval ( '1 + 1' )
2