python学习-列表和字典1

出自：https://blog.csdn.net/gavin_john/article/details/49893469

列表和字典这两种类型几乎是Python所有脚本的主要工作组件。

======================================================================================

列表

列表是：
任意对象的有序集合
通过偏移读取
可变长度、异构以及任意嵌套
属于可变序列的分类
对象引用数组

======================================================================================

基本的列表操作，前面已经有学过，这里只记录没学过或比较重要的

1.内置函数map，它对序列中的各项应用一个函数并把结果收集到一个新的列表中：

[python]  view plain  copy

1. >>> list(map(abs,[-1,-2,-3,1,2,3]))  
2. [1, 2, 3, 1, 2, 3]  

2.分片赋值：

[python]  view plain  copy

1. >>> L = [1,2,3]  
2. >>> L[:2]=[9,8]  
3. >>> L  
4. [9, 8, 3]  
5.   
6.   
7. >>> L  
8. [9, 8, 3]  
9. >>> L[1:2]=['a','b','c']  
10. >>> L  
11. [9, 'a', 'b', 'c', 3]  

分片赋值可以分成两步来理解：
（1）删除。删除等号左边指定的分片
（2）插入。将包含在等号右边对象中的片段插入旧分片被删除的位置。

--所以，插入元素的数目不需要与删除的数目相匹配。
--所以，分片赋值能够用来替换（覆盖）、增长（插入）、缩短（删除）主列表，这是功能强大的操作。

3.列表排序 sort,我们可以通过传入关键字参数来修改排序行为--这是指定按名称传递的函数调用中特殊的“name=value”语法。
在排序中，key参数给出了一个单个参数的函数，它返回在排序中使用的值，reverse参数允许排序按照降序而不是升序进行。

[python]  view plain  copy

1. >>> L = ['abc','ABD','aBc']  
2. >>> L.sort()  
3. >>> L  
4. ['ABD', 'aBc', 'abc']  
5. >>> L = ['abc','ABD','aBc']  
6. >>> L.sort(key=str.lower)  
7. >>> L  
8. ['abc', 'aBc', 'ABD']  
9. >>> L = ['abc','ABD','aBc']  
10. >>> L.sort(key=str.lower,reverse=True)  
11. >>> L  
12. ['ABD', 'abc', 'aBc']  

排序在最近的Python中可以作为内置函数使用了，它可以排序任何集合（不只是列表），并且针对结果返回一个新的列表（而不是原处修改）

[python]  view plain  copy

1. >>> L = ['abc','ABD','aBe']  
2. >>> sorted(L,key=str.lower,reverse=True)  
3. ['aBe', 'ABD', 'abc']  
4.   
5. >>> L = ['abc','ABD','aBe']  
6. >>> sorted([x.lower() for x in L],reverse=True)  
7. ['abe', 'abd', 'abc']  

注意上述两个例子的区别。

4.extend和pop方法分别能够在末端插入多个元素、删除一个元素。也有一个reversed内置函数，像sorted一样地工作，但是，它必须包装在一个list调用中，因为它是一个迭代器。

[python]  view plain  copy

1. >>> L =[1,2]  
2. >>> L.extend([3,4,5])  
3. >>> L  
4. [1, 2, 3, 4, 5]  
5. >>> L.pop()  
6. 5  
7. >>> L  
8. [1, 2, 3, 4]  
9. >>> L.reverse()  
10. >>> L  
11. [4, 3, 2, 1]  
12. >>> list(reversed(L))  
13. [1, 2, 3, 4]  

在某些类型的应用程序中，往往会把这里用到的列表pop方法和append方法联用，来实现快速的后进先出的（LIFO）堆栈结构。列表的末端作为堆栈的顶端

[python]  view plain  copy

1. >>> L  
2. [4, 3, 2, 1]  
3. >>> L.append(5)  
4. >>> L  
5. [4, 3, 2, 1, 5]  
6. >>> L.pop()  
7. 5  
8. >>> L  
9. [4, 3, 2, 1]  

pop方法也能够接受某一个即将删除并返回的元素的偏移（默认值为最后一个元素），这一偏移是可选的。其他列表方法可以通过值删除（remove）某元素，在偏移处插入（insert）某元素，查找某元素的偏移（index）等

[python]  view plain  copy

1. >>> L = ['spam','eggs','ham']  
2. >>> L.index('eggs')  
3. 1  
4. >>> L.insert(1,'toast')  
5. >>> L  
6. ['spam', 'toast', 'eggs', 'ham']  
7. >>> L.remove('eggs')  
8. >>> L  
9. ['spam', 'toast', 'ham']  
10. >>> L.pop(1)  
11. 'toast'  
12. >>> L  
13. ['spam', 'ham']  

5.其他常见的列表操作
由于列表是可变的，你可以用del语句在原处删除某项或某片段：

[python]  view plain  copy

1. >>> L  
2. ['SPAM!', 'eat', 'more', 'please']  
3. >>> del L[0]  
4. >>> L  
5. ['eat', 'more', 'please']  
6. >>> del L[1:]  
7. >>> L  
8. ['eat']  

因为分片赋值时删除外加插入操作，可以通过将空列表赋值给分片来删除列表片段。
==========================================================================================

字典

除了列表之外，字典也许是Python之中最灵活的内置数据结构类型。如果把列表看做是有序的对象集合，那么就可以把字典当成是无序的集合。它们主要的差别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

Python字典主要属性如下：
通过键而不是偏移量来读取
任意对象的无序集合
可变长、异构、任意嵌套
属于可变映射类型
对象引用表
【字典是唯一内置的映射类型（键映射到值的对象）】

字典解析：

[python]  view plain  copy

1. >>> D = {x:x*2 for x in range(10)}  
2. >>> D  
3. {0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}  

【1】.字典的update方法有点类似于合并，但是，他和从左到右的顺序无关，它把一个字典的键和值合并到另一个字典中，盲目地覆盖相同键的值：

[python]  view plain  copy

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

[python]  view plain  copy

1. >>> D2['muffin']=999  
2. >>> D.update(D2)  
3. >>> D  
4. {'muffin': 999, 'eggs': 3, 'ham': 1, 'spam': 2, 'toast': 4}  

【2】.字典的pop方法与列表类似，不过删除的是一个键而不是一个可选的位置

[python]  view plain  copy

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

【3】.使用字典可模拟灵活的列表，即键值用整数，这样用不到的索引不占用空间，反而提高了效率
【4】.字典用于稀疏数据结构
【5】.使用字典作为“记录”
【6】.创建字典的其他方法：

[python]  view plain  copy

1. （1）{'name':'mel','age':45}  
2. （2）  D = {}  
3.      D['name']='mel'  
4.      D['age']=45  
5. （3）dict(name='mel',age=45)  
6. （4）dict([('name','mel'),('age',45)])  

这四种形式都会建立相同的两键字典
如果所有键的值都相同，也可以用如下特殊形式对字典进行初始化：

[python]  view plain  copy

1. >>> dict.fromkeys(['a','b'],0)  
2. {'a': 0, 'b': 0}  

另外，zip函数是在一个单个调用中从键和值的列表来构建一个字典的方式之一。如果不能在代码中预计键和值的集合，总是可以将它们构建为列表然后再对应起来：

[python]  view plain  copy

1. >>> list(zip(['a','b','c'],[1,2,3]))  
2. [('a', 1), ('b', 2), ('c', 3)]  
3. >>> dict(zip(['a','b','c'],[1,2,3]))  
4. {'a': 1, 'b': 2, 'c': 3}  

在Python3.0中，可以用一个字典解析表达式来实现同样的效果

[python]  view plain  copy

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

字典解析应用如下：

[python]  view plain  copy

1. >>> D ={x :x**2 for x in range(1,6)}  
2. >>> D  
3. {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}  
4. >>> D = {c.lower():c+'!' for c in['SPAM','EGGS','HAM']}  
5. >>> D  
6. {'eggs': 'EGGS!', 'ham': 'HAM!', 'spam': 'SPAM!'}  

【7】：排序字典键

[python]  view plain  copy

1. D={ ... }  
2. for k in sorted(D.keys()):  
3. ...  

【8】:has_key方法已死：in永生

[python]  view plain  copy

1. >>> D  
2. {'a': 1, 'b': 2, 'c': 3}  
3. >>> D.has_key('a')  
4. Traceback (most recent call last):  
5.   File "<pyshell#77>", line 1, in <module>  
6.     D.has_key('a')  
7. AttributeError: 'dict' object has no attribute 'has_key'  
8. >>> 'a' in D  
9. True  
10. >>> 'a' in D.keys()  
11. True  

广为使用的字典has_key键存在测试方法在Python3.0中取消了，相反，使用in成员关系表达式，或者带有默认测试的一个get(其中，in通常是首选的)

[python]  view plain  copy

1. >>> D.get('c',0)  
2. 3  
3. >>> D.get('d',0)  
4. 0