列表

  • 序列操作:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

>>> l=[124,'spam',1.23]
>>> len(l)	#列出列表长度
3
>>> 
>>> l[0]	#列出元素
124
>>> l[-1]
1.23
>>> l[:-1]	#分片
[124, 'spam']
>>> l+[4,5,6]	#添加
[124, 'spam', 1.23, 4, 5, 6]
>>> l
[124, 'spam', 1.23]
>>>

  • 类型特定的操作:列表没有固定类型的约束;列表能够按照需要增加或减小列表大小,来响应其特定的操作:

    • append方法扩充了列表的大小并在列表的尾部插入一项
    • pop(或del语句)移除给定偏移的一项
    • 插入(insert)
    • 移除(remove)
    • sort,按照升序对列表进行排序
    • reverse对列表进行翻转
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

>>> l
[124, 'spam', 1.23]
>>> l.append('helloworld')
>>> l
[124, 'spam', 1.23, 'helloworld']
>>> l.pop(2)
1.23
>>> l
[124, 'spam', 'helloworld']
>>> l.sort()
>>> l
[124, 'helloworld', 'spam']
>>> l.reverse()
>>> l
['spam', 'helloworld', 124]
  • 边界检查:Python不允许引用不存在的元素.Python会进行错误检查
  • 嵌套:Python核心数据类型的一个优秀特性就是它们支持任意的嵌套.能够以任意的组合对其进行嵌套.并可以多深层次的嵌套.这种特性的一个直接应用就是实现矩阵,或者Python中的"多维数组".
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> l=[[1,2,3],[4,5,6],[7,8,9]]
>>> l
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> l[1]
[4, 5, 6]
>>> l[1][1]
5
>>> l[1][0]
4
>>> l[0][0]
1
>>>
  • 列表解析:列表解析表达式,处理矩阵.可以通过简单的索引即可获取行,使用列表解析可以同样获得列.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> l
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> col2=[row[1] for row in l]	#列表解析编写在方括号里,并且有表达式和循环结构都使用了一个变量名.
>>> col2
[2, 5, 8]
>>> l
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> [row[1] + 1 for row in l]
[3, 6, 9]
>>> [row[1] for row in l if row[1]%2==0]
[2, 8]
>>>

字典

  • 字典是一种映射.一个其他对象的集合.简单地将键映射到值.可变性.
  • 映射操作
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> D={'food':'Spam','quantity':4,'color':'pink'}
>>> D['food']
'Spam'
>>> D['color']
'pink'
>>> D['quantity'] += 1
>>> D
{'food': 'Spam', 'color': 'pink', 'quantity': 5}
>>> D['food']+='javascript'
>>> D
{'food': 'Spamjavascript', 'color': 'pink', 'quantity': 5}
  • 列表中的边界外的赋值是禁止的,对一个新的字典的赋值会创建该键
1
2
3
4
5
6
7
8
9

>>> D={}
>>> D['name']='Bob'
>>> D['job']=dev
>>> D['job']='dev'
>>> D['age']=40
>>> D
{'age': 40, 'job': 'dev', 'name': 'Bob'}
>>> print D['name']
Bob
  • 重访嵌套:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

>>> rec={'name':{'first':'Bob','last':'smith'},
... 'job':['dev','mgr'],
... 'age':40.5}
>>> rec['name']	#索引的是字典的键而不是列表的偏移
{'last': 'smith', 'first': 'Bob'}
>>> rec['name']['last']	#两重索引
'smith'
>>> rec['job']
['dev', 'mgr']
>>> rec['job'][-1]
'mgr'
>>> rec['job'].append('janitor')	#因为job列表是字典所包含的一部分独立的内存,可以自由地增加或减少.
>>> rec
{'age': 40.5, 'job': ['dev', 'mgr', 'janitor'], 'name': {'last': 'smith', 'first': 'Bob'}}	#运行表达式创建整个的嵌套对象结构.
>>>rec=0	#释放内存空间,在python中,一旦一个对象的最后一次引用被移除,空间将会立即回收.
>>>rec
0
  • 键的排序:for循环,作为映射,字典仅支持通过键获取元素.通过调用方法,也支持特定的操作
 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,'b':2,'c':3}
>>> D
{'a': 1, 'c': 3, 'b': 2}	#键不是序列,也许会以与我们输入时的不同的顺序出现.
###如果在一个字典的元素中,确实需要强调一个顺序的时候,可以通过字典的keys方法收集一个键的列表,并使用sort方法,然后使用python的for循环进行显示结果.
>>> ks=D.keys()
>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> ks
['a', 'c', 'b']	#键值还没排序
>>> ks.sort()
>>> ks
['a', 'b', 'c']	#排序好
>>> for key in ks:print key, '=>', D[key]
... 
a => 1
b => 2
c => 3
>>> for key in sorted(D):print key, '=>', D[key]	#通过sorted函数并对对象类型进行排序.
... 
a => 1
b => 2
c => 3
  • 迭代和优化:迭代协议,
1
2
3
4
5
6
7
8

>>> squares=[x**2 for x in [1,2,3,4,5]]
>>> squares
[1, 4, 9, 16, 25]
>>> squares=[]
>>> for x in [1,2,3,4,5]:squares.append(x**2)
... 
>>> squares
[1, 4, 9, 16, 25]	#列表解析通常运行地更快(第二种):这是大数据集合在程序中重要的原因之一
  • 不存在的键:if测试,字典的has_key方法允许我们查询一个键的存在性,并可以通过使用python的if语句对结果进行分支处理:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

>>> test={'a':1,'c':3,'b':2}
>>> test
{'a': 1, 'c': 3, 'b': 2}
>>> test['e']='test'
>>> test
{'a': 1, 'c': 3, 'b': 2, 'e': 'test'}
>>> test['d']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'd'
>>> test.has_key('f')
False
>>> test.has_key('a')
True
>>> if not test.has_key('f'):print 'missing'
... 
missing