Python学习笔记06

chapter_6

列表和字典

---

基本列表操作

>>> len([1,2,3])
3
>>> [1,2,3]+[4,5,6] #'+'和'*'运算符和字符串相同
[1, 2, 3, 4, 5, 6]
>>> ['Ni!'] * 4
['Ni!', 'Ni!', 'Ni!', 'Ni!']

---

列表方法调用

• 增加

>>> L = ['eat','more','SPAM!']
>>> L.append('please') #在列表尾部添加元素
>>> L
['eat', 'more', 'SPAM!', 'please']
>>> L.sort() #排序,按照ASCII进行从小到大排序
>>> L
['SPAM!', 'eat', 'more', 'please']

注意:对列表的操作是在原来的对象上直接操作的.

• 排序

>>> L = ['abc','ABD','aBe']
>>> L.sort() #默认按照ASCII进行从小到大排序
>>> L
['ABD', 'aBe', 'abc']
>>> L = ['abc','ABD','aBe']
>>> L.sort(key=str.lower) # #将列表中的每个元素变为小写，再按每个元素中的每个字母的ascii码从小到大排序 
>>> L
['abc', 'ABD', 'aBe']
>>> L = ['abc','ABD','aBe']
>>> L.sort(key=str.lower,reverse=True) #反过来,从大到小排序
>>> L
['aBe', 'ABD', 'abc']

注意:用append和sort在原处修改相关的列表对象,结果并没有返回列表,而是返回None.如果编辑类似 L = L.append(X) 的语句,会失去对列表的引用.

• sorted排序

>>> L = ['abc','ABD','aBe']
>>> sorted(L, key = str.lower, reverse = True) #对列表L进行排序,排序之前将所有的元素转为小写,并且以从大到小的方式进行排序
['aBe', 'ABD', 'abc']
>>> L = ['abc','ABD','aBe']
>>> sorted([x.lower() for x in L],reverse = True) #和上面的一样操作,只是结果略有不同,列表解析会产生一个新的副本
['abe', 'abd', 'abc']
>>> L #L本身没有被修改
['abc', 'ABD', 'aBe']

• 其他操作

>>> L = [1,2]
>>> L.extend([3,4,5]) #往列表中增加一个列表
>>> L
[1, 2, 3, 4, 5]
>>> L.pop() #删除最后一个元素
5
>>> L.pop(1) #删除指定索引的元素
2
>>> L
[1, 3, 4]
>>> L.reverse() #列表反转操作
>>> L
[4, 3, 1]
>>> list(reversed(L)) #列表反转,reversed()方法会产生一个迭代器,需要用list()方法进行解析
[1, 3, 4]

>>> L = ['spam','eggs','ham']
>>> L.index('eggs') #获取某元素的索引值
1
>>> L.insert(1,'toast') #在指定位置插入指定元素,原列表中的元素相应往后移
>>> L
['spam', 'toast', 'eggs', 'ham']
>>> L.remove('eggs') #删除指定元素
>>> L
['spam', 'toast', 'ham']
>>> L.pop(1) #删除指定索引元素
'toast'
>>> L
['spam', 'ham']

>>> L = ['SPAM!','eat','more','please']
>>> del L[0] #根据索引删除元素
>>> L
['eat', 'more', 'please']
>>> del L[1:] #删除多个元素
>>> L
['eat']

注意:有时候, pop( ) 方法和 append( ) 方法会联用来实现快速的后进先出 (LIFO, last-in-first-out)堆栈结构.

如:

>>> L = []
>>> L.append(1)
>>> L.append(2)
>>> L
[1, 2]
>>> L.pop()
2
>>> L
[1]

---

字典

>>> D = {'spam':2, 'ham':1,'eggs':3}
>>> D['spam'] #通过键索引
2
>>> D
{'eggs': 3, 'spam': 2, 'ham': 1} #字典是无序的,不能像列表那样通过偏移值来索引

>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}
>>> len(D) #获取字典的键值对个数
3
>>> 'ham' in D #测试字典中是否包含某个键,常在获取字典值前进行判断,避免出错
True
>>> list(D.keys()) #生成字典的键值列表
['eggs', 'spam', 'ham']

创建字典的方法

>>> D = {'name':'mel','age':45}

>>> D = {}
>>> D['name'] = 'mel'
>>> D['age'] = 45
>>> D
{'name': 'mel', 'age': 45}

>>> D = dict(name = 'mel',age=45)
>>> D
{'name': 'mel', 'age': 45}

>>> D = dict([('name','mel'),('age',45)])
>>> D
{'name': 'mel', 'age': 45}

• 如果所有的键的值都相同,可以用特殊的形式对字典进行初始化

>>> D = dict.fromkeys(['a','b'],0) #前面的是键列表,后面的是值
>>> D
{'a': 0, 'b': 0}

动态初始化字典(字典解析)

• 有时候,如果不能在代码中预计键和值的集合,可以先将它们构建为列表,然后再对应起来构成字典.

>>> list(zip(['a','b','c'],[1,2,3])) #zip() 函数能够将两个列表构建成一个迭代器,该迭代器每次返回两个列表对应位置的元组
[('a', 1), ('b', 2), ('c', 3)]
>>> D = dict(zip(['a','b','c'],[1,2,3])) #dict() 方法隐式的运行一个循环,能够根据迭代收集到的元组数据,填充到字典中
>>> D
{'a': 1, 'c': 3, 'b': 2}

• Python 3.0中,可以用字典解析表达式来实现同样的效果

>>> D = {k: v for (k,v) in zip(['a','b','c'],[1,2,3])}
>>> D
{'a': 1, 'c': 3, 'b': 2}

---

修改字典

>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}
>>> D['ham'] = ['grill','bake','fry']
>>> D
{'eggs': 3, 'spam': 2, 'ham': ['grill', 'bake', 'fry']}
>>> del D['eggs'] #删除字典的元素,有点类似列表
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry']}
>>> D['brunch'] = 'Bacon'
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry'], 'brunch': 'Bacon'}

• pop方法可以从字典中删除一个键并返回它的值,类似于列表中的pop()方法

>>> D
{'muffin': 5, 'eggs': 3, 'spam': 2, 'ham': 1, 'toast': 4}
>>> D.pop('muffin')
5
>>> D.pop('toast')
4
>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}

• 合并字典

>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}
>>> D2 = {'toast':4,'muffin':5}
>>> D.update(D2) #将字典D2合并到字典D中
>>> D
{'muffin': 5, 'eggs': 3, 'spam': 2, 'ham': 1, 'toast': 4}

---

其他字典方法

>>> D = {'spam':2,'ham':1,'eggs':3}
>>> list(D.values()) #获取字典的值的列表
[3, 2, 1]
>>> list(D.items()) #获取键和值的元组列表
[('eggs', 3), ('spam', 2), ('ham', 1)]

避免读取不存在的键而使程序崩溃

• 读取不存在的键时会出错,使用get方法如果读取不存在的键时,能够返回默认值(系统默认的None或者用户自定义的值)

>>> D
{'eggs': 3, 'spam': 2, 'ham': 1}
>>> D.get('spam') 
2
>>> print(D.get('toast')) #试图读取一个不存在的键,返回None
None
>>> D.get('toast',88) #读取不存在的键时,返回用户自定义的值88
88

• 三种方法防止读取不存在键的方法

>>> Matrix
{(2, 3, 4): 88, (7, 8, 9): 99}
>>> if (2,3,6) in Matrix: #读取键之前进行测试判断
...   print(Matrix[(2,3,6)])
... else:
...   print(0)
... 
0


>>> try:  #使用try语句捕获异常并恢复
...   print(Matrix[(2,3,6)])
... except KeyError:
...   print(0)
... 
0


>>> Matrix.get((2,3,6),0) #使用get方法
0
>>> Matrix.get((2,3,4),0)
88

---

使用字典注意事项

• 序列运算无效: 字典没有序列概念,只能通过键来获取值.
• 对新索引赋值会添加项.
• 键不一定总是字符串: 任何不可变对象都可以作为键(字符串,整数,元组等).

---

对字典进行排序

• sort( )方法实现

>>> D = {'a':1, 'b':2, 'c':3}
>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> Ks = D.keys() #生成的是字典键的迭代器
>>> Ks
dict_keys(['a', 'c', 'b'])
>>> Ks.sort() #sort( ) 方法不能用来对迭代器进行排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dict_keys' object has no attribute 'sort'
>>> Ks = list(Ks)
>>> Ks.sort()
>>> for k in Ks: print(k,D[k])
... 
a 1
b 2
c 3

• sorted( ) 方法实现

>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> Ks = D.keys()
>>> for k in sorted(Ks): print(k,D[k]) #sorted( )方法可以直接解析迭代器并排序,返回一个排序好的列表
... 
a 1
b 2
c 3

>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> sorted(D) #sorted() 方法可以直接提取字典的键并返回一个排好序的列表
['a', 'b', 'c']
>>> for k in sorted(D): print(k, D[k])
... 
a 1
b 2
c 3