列表

实际应用中的列表

合并和重复；迭代，成员关系；方法（增长，排序，搜索，插入，反转等）；方法语句：缩短
索引赋值，分片赋值；列表解析

基本列表操作

合并和重复

>>> L = [1, 2, 3]
>>> L1 = [4, 5, 6]
>>> L +L1
[1, 2, 3, 4, 5, 6]
>>> L.extend(L1)
>>> L
[1, 2, 3, 4, 5, 6]
>>> L*2
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

列表合并可以使用”+”和extend()函数，两者结果相同，但是+会重建一个列表对象，extend()函数会在原有列表的基础上进行修改。
重复的方式与字符串类型。

列表迭代和解析

列表解析是通过对序列中的每一项应用一个表达式来构建一的新的列表的方式。
列表的解析工作与for函数紧密联系

>>> L2 = []
>>> for c in 'spam':
    L2.append(c * 4)
>>> L2
['ssss', 'pppp', 'aaaa', 'mmmm']

在使用split()函数对列表进行类似字符串解析时，发现不能够应用

>>> L2.split(',')
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    L2.split(',')
AttributeError: 'list' object has no attribute 'split'

split()函数在字符串中的应用

>>> str ='ssss, pppp, aaaa, mmmm'
>>> str
'ssss, pppp, aaaa, mmmm'
>>> str.split(',')
['ssss', ' pppp', ' aaaa', ' mmmm']

索引、分片和矩阵

原处修改列表

索引与分片的赋值

索引与分片赋值方法

>>> L1 = [1, 2, 3]
>>> L2 = [4, 5, 6]
>>> L1[1]
2
>>> L1[2]
3
>>> L1[:2]
[1, 2]
>>> L1[0]= 2
>>> L1
[2, 2, 3]

索引与切片的赋值方法与字符串类似

索引与分片赋值不同点（分片赋值原理）

>>> L1 = [1, 2, 3]
>>> L1[0] = 3
>>> L1
[3, 2, 3]
>>> L1[0:1] = 3       # 分片赋值时，形式应为列表，否则报错
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    L1[0:1] = 3
TypeError: can only assign an iterable
>>> L1[0:1] = [1]
>>> L1
[1, 2, 3]
>>> L1[0:1] = [1,2,3] # 赋值个数多于分片个数
>>> L1
[1, 2, 3, 2, 3]

索引赋值与分片赋值方法还是不同的，索引赋值可以直接为数字，而分片赋值需为列表；
分片赋值时，基本操作逻辑是先删除分片上的值，然后再进行赋值，因此使用分片赋值，所赋值数可以与原分片所引用的个数不同。

列表方法调用

append() 函数的应用

append()函数应用于在列表末尾增加值，属于原位改变

>>> L1 = [1, 2, 3]
>>> L1.append(4)          # 增加数字
>>> L1
[1, 2, 3, 4]
>>> L1.append([4, 5])     # 增加列表
>>> L1
[1, 2, 3, 4, [4, 5]]
>>> L1.append('str')
>>> L1
[1, 2, 3, 4, [4, 5], 'str'] # 增加字符串

append()函数本身就属于原位修改，所以不用写成 L1 = L1.append()形式，如果写成这种形式会导致L1引用失效。

>>> L1 = L1.append(6)
>>> L1
>>> type(L1)
<class 'NoneType'>

sort() 函数的应用

sort()函数括号内可以加入key值，如reverse为反转。

>>> L1 = [1, 2, 3, 4]
>>> L1.sort()
>>> L1
[1, 2, 3, 4]
>>> L1.sort(reverse = True)
>>> L1
[4, 3, 2, 1]

sorted()可以取得与sort()函数相同的效果，但需要给予输出函数新的变量

>>> L2 = [1,4, 2,3]
>>> sorted(L2)
[1, 2, 3, 4]
>>> L2
[1, 4, 2, 3]

pop();index();insert()

pop()函数删除列表中的最后一个值

>>> L1
[4, 3, 2, 1]
>>> L1.pop()
1
>>> L1
[4, 3, 2]

index()函数从列表中搜索，并返回值所在的位置

>>> L1
[4, 3, 2]
>>> L1.index(3)
1
>>> L1.index(5)
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    L1.index(5)
ValueError: 5 is not in list

如果值不在列表中，则报错。
inset()函数在列表中特定位置插入值

>>> L1
[4, 6, 3, 2]
>>> L1.insert(1, 8) # 在偏移为1的位置插入 8
>>> L1
[4, 8, 6, 3, 2]

其他常见列表操作

删除操作

del语句

>>> L1
[4, 'insert', 8, 6, 3, 2]
>>> del L1[1]   # del语句使用
>>> L1
[4, 8, 6, 3, 2]
>>>

分片应用

>>> L1[0:3]= [] # 切片应用
>>> L1
[3, 2]

注意：索引和分片虽然都用到了偏移量，但是在赋值时，两者还是有区别。

字典

字典的结构与列表不同，字典为无序结构，所以无法通过偏移进行引用，只能通过键进行引用；
字典中保存的项是没有顺序的，其键值对从左到右随机排列，以便快速查找（散列查找）；
字典可以在原地更改，增加或延长；

实际应用中的字典

字典的基本操作

字典读取方式
散列查找
len()函数
in成员关系测试

字典定义了单步遍历keys列表的迭代器

>>> dic = {'a':1, 'b':2, 'c':3}
>>> dic['a']
1
>>> len(dic)
3
>>> 'a' in dic
True

原处修改字典

修改、扩展及缩短
删除

>>> dic
{'a': 1, 'b': 2, 'c': 3}
>>> dic['a'] = 2                  # 修改
>>> dic
{'a': 2, 'b': 2, 'c': 3}
>>> dic['d'] = 4                  # 扩展
>>> dic
{'a': 2, 'b': 2, 'c': 3, 'd': 4}  
>>> del dic['a']                  # 缩短
>>> dic
{'b': 2, 'c': 3, 'd': 4}

其他字典方法

values和items

>>> dic
{'b': 2, 'c': 3, 'd': 4}
>>> print(dic.keys())
dict_keys(['b', 'c', 'd'])
>>> print(dic.values())
dict_values([2, 3, 4])
>>> print(dic.items())
dict_items([('b', 2), ('c', 3), ('d', 4)])

get方法

在读取字典中不存在的键时，经常性出错，get方法在读取时，如过不存在则返回None，或者默认值

>>> dic
{'b': 2, 'c': 3, 'd': 4}
>>> dic.get('b')
2
>>> dic.get('a')
>>> print(dic.get('a'))  # 如无规定默认值，则输出None
None
>>> dic.get('a', 5)      # 5为默认值，手动输入
5

update()函数如果有相同的键怎么办

>>> dic
{'b': 2, 'c': 3, 'd': 4}
>>> dic1 = {'a':1}
>>> dic.update(dic1)
>>> dic
{'b': 2, 'c': 3, 'd': 4, 'a': 1}
>>> dic2 = {'a':2}
>>> dic.update(dic2)            # 与dic含有相同的键值 'a'
>>> dic
{'b': 2, 'c': 3, 'd': 4, 'a': 2}

pop()函数

与列表不同，pop()函数返回所对应的键值。

>>> dic
{'b': 2, 'c': 3, 'd': 4, 'a': 2}
>>> dic.pop('b')
2
>>> dic
{'c': 3, 'd': 4, 'a': 2}

语言表

for 循环的运用

>>> dic
{'c': 3, 'd': 4, 'a': 2}
>>> for i in dic:print(i)
c
d
a
>>> for i in dic.keys():print(i)
c
d
a

字典用法注意事项

序列运算无效
对新索引赋值会增加项
键不一定总是字符串

使用字典模拟灵活的列表
用字典模拟列表通过偏移进行引用

在使用列表时，如果超出列表的偏移量，引用会报错

>>> lis = []
>>> lis[1]
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    lis[1]
IndexError: list index out of range

可以使用字典对类似偏移进行引用

>>> lis = {}
>>> lis[9] = 1
>>> lis
{9: 1}

字典用于稀疏数据结构

稀疏数据结构

在多维数据结构中，个别点进行赋值而其他点无值。

避免missing-key错误

if 语句
try语句
get方法

使用字典作为“记录”

创建字典的其他方法

常规
动态
关键字形式
键值序列形式
与zip函数
fromkeys()
字典解析表达式

>>> dic1 = {'a':1, 'b':2}
>>> dic1
{'a': 1, 'b': 2}
>>> dic2 = {}
>>> dic2['a'] = 1
>>> dic2
{'a': 1}
>>> dic3 = dict(a = 1, b = 2)                # 关键字形式
>>> dic3
{'a': 1, 'b': 2}
>>> dic4 = dict([('a', 1), ('b', 2)])        # 键值对
>>> dic4
{'a': 1, 'b': 2}
>>> dic6 = dict.fromkeys(['a', 'b', 'c'], 1) # 对于值相同的形式
>>> dic6
{'a': 1, 'b': 1, 'c': 1}

Python 3.0中的字典变化

字典解析

字典的解析就是运用一个循环，把每次循环得出的键值对添加到字典中。
动态初始化一个字典的标准：把键和值对应起来并供给dict函数调用。
zip函数
字典解析表达式
从键列表来初始化字典

字典视图

视图对象 keys(), values(), items()函数均返回字典的视图对象

>>> dic
{'b': 2, 'c': 3, 'd': 4}
>>> print(dic.keys())
dict_keys(['b', 'c', 'd'])
>>> print(dic.values())
dict_values([2, 3, 4])
>>> print(dic.items())
dict_items([('b', 2), ('c', 3), ('d', 4)])

视图对象可迭代

>>> for i in dic.keys():print(i, '\t', dic[i])
b      2
c      3
d      4
>>> for v in dic.values():print(v)
2
3
4
>>> for i in dic.items():print(i)
('b', 2)
('c', 3)
('d', 4)

视图对象还保持着字典成分的最初顺序，反映未来的变化，支持集合操作

>>> dic
{'c': 3, 'd': 4}
>>> k = dic.keys()
>>> print(k)
dict_keys(['c', 'd']) # k值初始
>>> del dic['c']
>>> print(k)
dict_keys(['d'])      # 字典改变后，k值发生改变

视图对象不是列表不支持列表的排序、切片、索引操作

>>> dic = {'b': 2, 'c': 3, 'd': 4}
>>> k = dic.keys()
>>> k[1]                                            # 索引
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    k[1]
TypeError: 'dict_keys' object is not subscriptable
>>> k[0:1]                                          # 切片                                            
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    k[0:1]
TypeError: 'dict_keys' object is not subscriptable
>>> k.sort()                                        #排序
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    k.sort()
AttributeError: 'dict_keys' object has no attribute 'sort'

如果想用列表操作或者显示他们的值，必须使用list()函数

>>> dic.keys()
dict_keys(['b', 'c', 'd'])
>>> list(dic.keys())
['b', 'c', 'd']
>>> dic.values()
dict_values([2, 3, 4])
>>> list(dic.values())
[2, 3, 4]
>>> dic.items()
dict_items([('b', 2), ('c', 3), ('d', 4)])
>>> list(dic.items())
[('b', 2), ('c', 3), ('d', 4)]

Python的循环结构会迫使可迭代函数返回一个结果值。

>>> dic
{'b': 2, 'c': 3, 'd': 4}
>>> for i in dic:print(i)
b
c
d
>>> for i in dic.keys():print(i)
b
c
d

Python3.0版本中的字典拥有自己的迭代器
Python3.0中字典视图创建后仍可改变，可以动态的反应字典修改后的变化

字典视图和几何（集合）

keys()所返回的字典视图能够进行集合操作

>>> dic
{'b': 2, 'c': 3, 'd': 4}
>>> dic2 = {'a' :1}
>>> dic.keys()|dic2
{'a', 'c', 'd', 'b'}

values()返回视图不能

>>> dic.values() | dic2
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    dic.values() | dic2
TypeError: unsupported operand type(s) for |: 'dict_values' and 'dict'

items()如果返回（key，values）对是唯一并且可散列的可以进行集合操作。（这一点不明白）

>>> dic.items() | dic2
{'a', ('b', 2), ('c', 3), ('d', 4)}

排序字典键

手动转换
使用sorted调用

>>> dic
{'b': 2, 'c': 3, 'd': 4}
>>> for i in sorted(dic.keys()):print(i,'\t',dic[i])
b      2
c      3
d      4

python学习笔记

第8章列表与字典

列表

实际应用中的列表

基本列表操作

列表迭代和解析

索引、分片和矩阵

原处修改列表

索引与分片的赋值

列表方法调用

其他常见列表操作

字典

实际应用中的字典

字典的基本操作

原处修改字典

其他字典方法

语言表

字典用法注意事项

使用字典模拟灵活的列表

字典用于稀疏数据结构

避免missing-key错误

使用字典作为“记录”

创建字典的其他方法

Python 3.0中的字典变化

字典解析

字典视图

字典视图和几何（集合）

排序字典键

字典大小比较不再有效

第8章 列表与字典

列表

实际应用中的列表

基本列表操作

列表迭代和解析

索引、分片和矩阵

原处修改列表

索引与分片的赋值

列表方法调用

其他常见列表操作

字典

实际应用中的字典

字典的基本操作

原处修改字典

其他字典方法

语言表

字典用法注意事项

使用字典模拟灵活的列表

字典用于稀疏数据结构

避免missing-key错误

使用字典作为“记录”

创建字典的其他方法

Python 3.0中的字典变化

字典解析

字典视图

字典视图和几何（集合）

排序字典键

字典大小比较不再有效

第8章列表与字典