Python笔记：第二部分 类型和运算 第8章 列表与字典

列表

列表的属性

Python中列表是最灵活的有序集合对象类型

• 任意对象的有序集合
  列表就是收集其他对象的地方，同时维护了每一项从左到右的位置顺序（序列）。
• 通过偏移访问
  类似字符串，可以通过列表对象的偏移进行索引、读取。由于有序性，可以执行分片和拼接之类的任务。
• 可变长度、异构以及任意嵌套
  与字符串不同，列表可以原位置改变，并且可以包含任何类型的对象。因此可以创建列表的子列表。
• 属于“可变序列”的分类
  就类型分类——列表是可变对象（原位置修改），可响应所有针对字符串的序列操作（索引、分片、拼接）。
• 对象引用数组
  从技术上——列表包含零个多个其他列表的引用。Python总将引用指向一个对象，每当将一个对象赋值给一个数据结构组件或变量名时，Python总会存储同一个对象的引用而不是对象的副本。

常用列表字面量和操作

列表的实际应用

基本列表操作

• “+” ，“*” 与字符串类似，意思为拼接和重复。结果是一个新的列表。
• “+”，“*”两边必须是相同类型的序列，否则运行时会出现类型错误。

列表迭代和推导

• 后续联系其他整理

索引、分片和矩阵

• 索引、分片与字符串相同
• 矩阵

>>>matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>>matrix = [1]
[4,5,6]
>>>matrix[1][1]
5
>>>matrxi[2][0]
7

1.由于可以在列表中镶嵌列表（或其他对象类型），有时候需要将几次索引操作连在一起使用深入到数据结构中。
2.表示矩阵（多维数组）：在Python中相当于嵌套了子列表的子列表。

原位置修改列表

索引与分片赋值

• 在使用列表时，可以将它赋值给一个特定项（偏移）或整个片段（分片）来改变它的内容

>>>L = ['spam','Spam','SPAM']
>>>L[1] = 'egg'
>>>L
['spam','egg','SPAM']
>>>L[0:2]=['eat','more']
>>>L
['eat','more','SPAM']

• 索引和分片的赋值都是原位置修改，它对列表的主体进行直接修改，而不是生成一个新的列表做结果。Python中的索引赋值与C及大多数其他语言类似——Python用一个新值取代单个指定偏移的对象引用。
• 分片赋值的操作理解：
  1.删除：删除等号左边指定的分片。
  2.插入：将包含在等号右边可迭代对象中的片段插入旧分片被删除的位置。
  3.因此，插入元素的数目不需要与删除的数目相匹配。

列表方法调用

• Python列表对象也支持特定类型方法调用，其中很多调用可以原位置修改主体列表

>>>L=['eat','more','SPAM']
>>>L.append('please')
>>>L
['eat','more','SPAM','please']
>>>L.sort()
>>>L
['SPAM','eat','more','please']

• 常用的列表方法：append方法
  它能够简单的将一个单项（对象引用）加至列表末端。不同于拼接，append允许传入单一对象而不是只是列表。

更多关于列表排序

List.sort()方法

1. 描述：sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
2. 方法：list.sort(cmp=None, key=None, reverse=False)
3. 参数:
   • cmp:可选参数, 如果指定了该参数会使用该参数的方法进行排序。
   • key:主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
   • reverse:排序规则，reverse = True 降序， reverse = False 升序（默认）
4. 实例

>>>aList = [123, 'Google', 'Runoob', 'Taobao', 'Facebook']
>>>aList.sort()
>>>print("List : ", aLis)
List :  [123, 'Facebook', 'Google', 'Runoob', 'Taobao']


>>>vowels = ['e', 'a', 'u', 'o', 'i']    # 列表
>>>vowels.sort(reverse=True)   # 降序
>>>print('降序输出:', vowels)   # 输出结果
降序输出: ['u', 'o', 'i', 'e', 'a']

>>>def takeSecond(elem): # 获取列表的第二个元素
    return elem[1]
>>>random = [(2, 2), (3, 4), (4, 1), (1, 3)]  # 列表
>>>random.sort(key=takeSecond)  # 指定第二个元素排序
>>>print('排序列表：', random)    # 输出类别
排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

向列表中增加元素

• list.append(单个元素)：在list列表末端增加一个元素
• list.extend( [ 元素1，元素2 ] )：在list列表末端增加多个元素
• list.insert(元素序号，元素)：在list列表任意位置增加一个元素

从列表中删除元素

• list.remove(元素)：从列表中删除一个元素，且并不要求此元素的位置
• del list[元素序号]：从列表中删除指定位置的元素或片段,原位置修改而不生成新列表

>>>L = ['spam','SPAM','SpAm','FUCK']
>>>del L[0]
>>>L
['SPAM','SpAm','FUCK']
>>>del L[1:]
>>>L
['SPAM']

• list.pop(元素)：从列表中弹出一个元素，则list列表中少一个元素，默认值为-1
• list.pop(元素序号)：从列表中指定弹出一个元素，则list列表中少一个元素

其他操作

• a = list.count(元素)：计算它的参数在列表中出现的次数，并将次数返回；
• a = list.index(元素)：返回它的参数在列表中的位置，返回元素序号；若有多个元素相同，此为只返回首端起第一个。
• a = list.index(元素， 序号1，序号2)：在序号1和序号2范围内，返回列表中元素位置。 #若有多个元素相同，此为只返回首端起第一个。
• list.reverse()：将整个列表内元素反过来排列：[1, 2, 3, 4].reverse() == [4, 3, 2, 1]

字典

字典的属性

列表是有序对象的集合，字典是无序对象的集合。

• 通过键而不是通过偏移量来存取
  字典有时被叫做关联数组或者散列表,也可以通过索引操作从字典获取内容，但是索引采取键的形式而不是相对偏移。
• 任意对象的无需结合
• 长度可变、异构、任意嵌套
  与列表相似，字典可以在原位置增长或缩短，他们可以包含任何类型的对象，且它们支持任意深度的嵌套（可以包含列表和其他字典等),每一个键只有一个与之相关联的值，但这个值可以是一系列多个所需对象的集合，而一个值也可以同时存储在多个键下。
• 属于“可变映射”类型
  通过给索引赋值，字典可以在原位置修改（可变性），但不支持用于字符串和列表的序列操作。实际上，因为子电视无序集合，所以根据固定顺序进行操作是行不通的，相反字典是唯一内置的、核心的映射类型。
• 对象引用表（散列表）
  从本质讲，字典是作为散列表（支持快速检索的数据结构）来实现的，和列表一样，字典存储的是对象引用。

常见字典字面量和操作

字典的实际应用

字典的基本操作

• 通常情况下，创建字典并通过键来存储、访问其中的某项

>>> D = { 'spam' :2,'ham‘：2，’egg':3}  #创建一个字典
>>> D ['spam']
2
>>>D
{ 'spam' :2,'ham‘：2，’egg':3}  

1. 字典是另一种可变容器模型，且可存储任意类型对象。
2. 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
   d = {key1 : value1, key2 : value2 }
3. 键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

dict1 = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict2 = { 'abc': 456 }
dict3 = { 'abc': 123, 98.6: 37 }

字典的基本用法

字典包含多个 key-value 对，而 key 是字典的关键数据，因此程序对字典的操作都是基于 key 的。

1. 通过 key 访问 value 。

>>>scores = {'语文': 89}
'''通过key访问value'''
>>>print(scores['语文'])
{'语文': 89}

2. 通过 key 添加 key-value 对。

'''对不存在的key赋值，就是增加key-value对'''
>>>scores = {'语文': 89}
>>>scores['数学'] = 93
>>>scores[92] = 5.7
>>>print(scores)
{'语文': 89, '数学': 93, 92: 5.7}

3. 通过 key 删除 key-value 对。

'''使用del语句删除key-value对'''
>>>scores = {'语文': 89, '数学': 93, 92: 5.7}
>>>del scores['语文']
>>>del scores['数学']
>>>print(scores)
{92: 5.7}
'''del dict['Name'] # 删除键 'Name'
   del dict         # 删除字典'''

4. 通过 key 修改 key-value 对。

>>>cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
'''对存在的key-value对重新赋值，改变key-value对'''
>>>cars['BENS'] = 4.3
>>>cars['AUDI'] = 3.8
>>>print(cars) 
{'BMW': 8.5, 'BENS': 4.3, 'AUDI': 3.8}

5. 通过 key 判断指定 key-value 对是否存在。

'''则可以使用 in 或 not in 运算符。需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。'''
>>>print('AUDI' in cars) 
True
>>>print('PORSCHE' in cars) 
False
>>>print('LAMBORGHINI' not in cars) 
True

6. 通过key 访问 value 使用的是 方括号语法，就像前面介绍的列表和元组一样，只是此时在方括号中放的是 key，而不是列表或元组中的索引。

字典的常用方法

1. 内置的len函数也可以用于字典，它能够返回存储在字典内元素的数目，或者说是其keys列表的长度
2. 字典的in/not in 成员关系运算符提供了键存在与否的测试方法
3. 使用str(dict) 输出字典，以可打印的字符串形式表示。

>>>D = {'spma':2,'ham':1,'eggs':3}
>>>list(D.values()）
[3,2,1]
>>>list(d.items())
[('eggs':3),('spma':2),('ham':1)]

4. get方法
   通过key 来获取 value，方括号语法的增强版，当使用方括号语法访问并不存在的 key时，字典会引发 missing-key 错误；但如果使用** get() 方法访问不存在的 key**，会返回默认值—None或用户自定义默认值。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
'''获取'BMW'对应的value'''
>>>print(cars.get('BMW')) 
>8.5
>>>print(cars.get('PORSCHE')) 
None
>>>print(cars.get('PORSCHE',88))
88
>>>print(cars['PORSCHE']) 
KeyError

5. clear()方法
   用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。

>>>cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
'''清空cars所有key-value对'''
>>>cars.clear()
>>>print(cars)
{}

6. update()方法
   可把一个字典的value和key拼接到另一个字典中，遇到键冲突时盲目的覆盖相同键的值。

>>>cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>>cars.update({'BMW':4.5, 'PORSCHE': 9.3})
>>>print(cars)
cars = {'BMW': 4.5, 'BENS': 8.3, 'AUDI': 7.9,'PORSCHE': 9.3}

7. pop方法
   用于返回指定 key 对应的 value，并删除这个 key-value 对。

>>>cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
>>>print(cars.pop('AUDI'))
7.9
>>>print(cars)
{'BMW': 8.5, 'BENS': 8.3}

8. popitem方法
   用于随机弹出字典中的一个 key-value 对,弹出的是一个元组.

此处的随机其实是假的，正如列表的 pop() 方法总是弹出列表中最后一个元素
实际上字典的 popitem() 其实也是弹出字典中最后一个 key-value 对。
由于字典存储 key-value 对的顺序是不可知的，
因此开发者感觉字典的 popitem() 方法是“随机”弹出的
但实际上字典的 popitem() 方法总是弹出底层存储的最后一个 key-value 对。

>>>cars = {'AUDI': 7.9, 'BENS': 8.3, 'BMW': 8.5}
'''弹出字典底层存储的最后一个key-value对'''
>>>print(cars.popitem()
('AUDI', 7.9)
>>>print(cars) 
{'BMW': 8.5, 'BENS': 8.3}

由于实际上 popitem 弹出的就是一个元组，因此程序完全可以通过序列解包的方式用两个变量分别接收 key 和 value

'''将弹出项的key赋值给k、value赋值给v'''
>>>k, v = cars.popitem()
>>>print(k, v)
BENS 8.3

9. values()、items()、keys() 三个方法依次返回dict_values 、 dict_items和 dict_keys对象，Python 不希望用户直接操作这几个方法，但可通过 list() 函数把它们转换成列表。

• values方法
  返回字典中所有的value

>>>D = {'spam'=2, 'ham'=1, 'eggs'=3}
>>>list(D.values())
[3,2,1]

• items方法
  返回字典中所有**(key,value)对元组**

>>>D = {'spam'=2, 'ham'=1, 'eggs'=3}
>>>list(D.items())
[('spam'=2),('ham',1),('eggs',3)]

• keys方法
  返回字典中所有的key列表

>>>D = {'spam'=2, 'ham'=1, 'eggs'=3}
>>>list(D.keys())
['spam','ham','eggs']

10. setdefault方法
    setdefault() 方法总能返回指定 key 对应的 value；如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 设置默认的 value，然后再返回该 key 对应的 value。

>>>cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
'''设置默认值，该key在dict中不存在，新增key-value对'''
>>>print(cars.setdefault('PORSCHE', 9.2)) 
9.2
>>print(cars)
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9,'PORSCHE':9.2}
'''设置默认值，该key在dict中存在，不会修改dict内容''
>>>print(cars.setdefault('BMW', 3.4))
8.5
>>>print(cars)
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9,'PORSCHE':9.2}

字典用法注意事项

• 序列运算无效
  字典是映射机制，不是序列。因为字典元素间键没有顺序的概念，类似拼接和分片无法使用。
• 对新索引赋值会添加项
• 键不一定总是字符串
  任何不可变对象都可以成为键， 可变对象虽然不可以成为键，但可以作为值。

创建字典的其他方式

>>>{'name':bob,'age':40}    # traditional literal expression
'''如果可以事先拼出整个字典，第一种较方便'''

>>>D={}       # assign by keys dynamically
>>>D['name']='bob'
>>>D['age']=40
'''如果需要一次动态建立字典的一个字段，第二种合适'''

>>>dict(name='bob',age=40)   # dict keyword argument form
'''关键词形式所需的代码比字面量少，但键必须都是字符串才行'''

>>>dict([('name','bob'),('age',40)])   # dict key/value tuples form
'''如果需要在程序运行时通过序列构建字典，最后一种有用'''

第三种形式在如今的Python代码中比较流行，因为它语法简单而且不易出错。

字典与列表的比较