python学习手册:学习笔记6--Lists and Dictionaries
博客专区 > fzyz_sb 的博客 > 博客详情
python学习手册:学习笔记6--Lists and Dictionaries
fzyz_sb 发表于3年前
python学习手册:学习笔记6--Lists and Dictionaries
  • 发表于 3年前
  • 阅读 165
  • 收藏 0
  • 点赞 0
  • 评论 0

腾讯云 技术升级10大核心产品年终让利>>>   

List

    列表是可改变的容器,并且它的元素可包含任意的数据类型:数字,字符串,甚至列表本身.

Python中列表的属性如下:

Ordered collections of arbitrary objects

    列表的元素可包含任意的数据类型,我们可以把列表当作一个"组"

Accessed by offset

    因为列表本身是序列容器,所以我们可以对它进行索引操作,甚至可以对它进行切片操作.

variable-length, heterogeneous, and arbitrary nestable

    不像字符串,列表可以在空间层面上增加和减少,它们可以包含任何可排序/不可排序的对象,甚至可以包含列表本身.

Of the category "mutable sequence"

    列表是可修改的(跟字符串不同,字符串/数字是不可修改的),任何在字符串上可执行的操作/方法在列表上均可实现:切片,连接,索引等.由于列表是可修改的,所以它支持额外的功能:删除,索引赋值(直接在列表的空间上进行修改)

    以下为列表的通用操作:

Operation
Interpretation
L = []
空列表
L = [123, 'abc', 1.23, {}]
四个元素的列表
L = ['Bob', 40.4, ['dev', 'mgr']]
列表中嵌套列表
L = list('spam')
使用可迭代对象生成列表
L = list(range(-4, 4))

L[i]
列表的索引,索引的索引,切片,长度
L[i][j]

L[i:j]

len(L)

L1 + L2   
列表的连接,重复
L * 3

for x in L: print(x)
可迭代操作
3 in L
成员判断操作
L.append(4)
列表的操作:增长
L.extend([5, 6, 7])

L.insert(i, x)

L.index(X)
列表的操作:查询
L.count(X)

L.sort()
列表的操作:排序,反序
L.reverse()

L.copy()

L.clear()

L.pop(i)
列表的操作:删除
L.remove(X)

del L[i]

del L[i:j]

L[i:j] = []

L[i] = 3
列表的操作:赋值,切片赋值
L[i:j] = [4, 5, 6]

L = [x ** 2 for x in range(5)]

list(map(ord, 'spam'))

Lists in Action

    列表和字符串类似,一样支持"+"和"*"的操作.而如果对字符串和列表进行"+"操作,则需进行强制转换:

>>> len([1, 2, 3])
3
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> ['Ni!'] * 4
['Ni!', 'Ni!', 'Ni!', 'Ni!']
>>> str([1, 2]) + "34"
'[1, 2]34'
>>> [1, 2] + list("34")
[1, 2, '3', '4']
    列表也可以进行可迭代操作
>>> 3 in [1, 2, 3]
True
>>> for x in [1, 2, 3]:
	print x,

	
1 2 3
    通过for/range/map来进行可迭代操作:
>>> res = [c * 4 for c in 'SPAM']
>>> res
['SSSS', 'PPPP', 'AAAA', 'MMMM']
	等价于:
>>> res = []
>>> for c in 'SPAM':
	res.append(c * 4)

	
>>> res
['SSSS', 'PPPP', 'AAAA', 'MMMM']
    而map可进行元素和方法的关联操作:
>>> list(map(abs, [-1, -2, 0, 1, 2]))
[1, 2, 0, 1, 2]
    列表进行索引,切片和矩形计算(但切片的操作是生成一个新的列表)
>>> L = ['spam', 'Spam', 'SPAM!']
>>> L[2]
'SPAM!'
>>> L[-2]
'Spam'
>>> L[1:]
['Spam', 'SPAM!']
>>> matrix = [(x, y) for x in range(1, 3) for y in range(1, 5)]
>>> matrix
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4)]
备注:对于复杂的操作,不要使用列表推导式!
    列表和字符串有一个很大的区别在于:列表可更改自身,即它是可修改的.
    我们可以通过索引或者切片来对列表进行修改:
>>> L = ['spam', 'Spam', 'SPAM!']
>>> L[1] = 'eggs'
>>> L
['spam', 'eggs', 'SPAM!']
>>> L[0:2] = ['eat', 'more']
>>> L
['eat', 'more', 'SPAM!']
    基于:数字/字符串是不可改变的,所以我们可以通过id来查看其变化:
>>> L = [1, 2, 3]
>>> id(L), [id(x) for x in L]
(42282376L, [29253736L, 29253712L, 29253688L])
>>> L[1] = 12
>>> id(L), [id(x) for x in L]
(42282376L, [29253736L, 29253472L, 29253688L])
    实际上我们新建了一个对象12,并让指针指向新的对象.
    对于切片的赋值来说,我们实际上执行了两步操作:
1. 删除:我们将切片要赋值的范围内元素删除
2. 插入:在删除的位置上插入新的元素(用C语言实现的Python的列表,应该是链式列表,否则不可以插入空间大小不同的元素)
    所以,我们可以用切片的赋值完成删除,插入,替换等操作:
>>> L = [1, 2, 3]
>>> L[1:2] = [4, 5]
>>> L
[1, 4, 5, 3]
>>> L[1:1] = [6, 7]
>>> L
[1, 6, 7, 4, 5, 3]
>>> L[1:2] = []
>>> L
[1, 7, 4, 5, 3]
>>> L= [1]
>>> L[0:0] = [2, 3, 4]
>>> L
[2, 3, 4, 1]
>>> L[len(L):] = [5, 6, 7]
>>> L
[2, 3, 4, 1, 5, 6, 7]
>>> L.extend([8, 9, 10])
>>> L
[2, 3, 4, 1, 5, 6, 7, 8, 9, 10]
    列表也支持一些方法的操作:
    我们可以使用append方法来在末尾插入一项,通过sort方法来排序:
>>> L = ['eat', 'more', 'SPAM!']
>>> L.append('please')
>>> L
['eat', 'more', 'SPAM!', 'please']
>>> L.sort()
>>> L
['SPAM!', 'eat', 'more', 'please']
    我们可以通过"name=value"的方法来进行排序:
>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort()
>>> L
['ABD', 'aBe', 'abc']
>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort(key=str.lower)
>>> L
['abc', 'ABD', 'aBe']
>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort(key=str.lower, reverse=True)
>>> L
['aBe', 'ABD', 'abc']
    这里要注意一点是:使用类似sort/reverse方法,实际上直接修改了列表.但是如果使用了sorted/reversed等方法,不会修改列表但返回一个新的列表:
>>> L = ['abc', 'ABD', 'aBe']
>>> sorted(L, key=str.lower, reverse=True)
['aBe', 'ABD', 'abc']
>>> L
['abc', 'ABD', 'aBe']
>>> sorted([x.lower() for x in L], reverse=True)
['abe', 'abd', 'abc']
    append和extend方法不同之处在于:append只能扩展单个元素,而extend往往扩展整个列表.我们可以配合append和pop来完成一个堆栈的操作:
>>> L = []
>>> L.append(1)
>>> L.append(2)
>>> L
[1, 2]
>>> L.pop()
2
>>> L
[1]
    还有一些额外的操作如:index(查找其元素的索引),insert(在指定的位置插入元素),remove(删除其元素:第一次出现的元素),count(统计出现元素的次数)
>>> 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()
'ham'
>>> L.count('spam')
1
    我们甚至可以使用del来删除元素,或者使用切片赋值来完成:
>>> L = ['spam', 'eggs', 'ham', 'toast']
>>> del L[0]
>>> L
['eggs', 'ham', 'toast']
>>> del L[1:]
>>> L
['eggs']
>>> L = ['Already', 'got', 'one']
>>> L[1:] = []
>>> L
['Already']
>>> L[0] = []
>>> L
[[]]


Dictionaries

    对于Python的字典来说,有如下属性:

Accessed by key, not offset position

    字典有时候也称为关联数组或者哈希表,我们是通过其关键字来进行数据的读取的.

unordered collections of arbitrary objects

    对于字典来说,在空间上并不是顺序存储的,而是通过类似哈希表的方式实现.

variable-length, heterogeneous, and arbitrary nestable

    跟列表类似,字典可以增加也可以减少,它们可以包含任何的数据类型,也支持嵌套.但是对于键值来说,必须是可哈希的,即不可改变,如字符串/数值/集合等.

of the category "mutable mapping"

    字典是可修改的,所以可以通过赋值的方式实现.但是它不支持字符串/列表的绝大部分操作,因为它并不是顺序存储的.

tables of object references(hash tables)

    字典是由哈希表实现的,所以它是通过键值来进行数据的读取.

以下表格是字典的所有操作:

Operation
Interpretation
D = {}
空字典
D = {'name': 'Bob', 'age': 40}
两个元素的字典
E = {'cto': {'name': 'Bob', 'age': 40}}
嵌套的字典
D = dict(name='Bob', age=40)
使用dict函数(元素为可迭代的哈希结构即可)实现的字典:keywords,key/value pairs, zipped key/value pairs, keylists
D = dict([('name', 'Bob'), ('age', 40)])

D = dict(zip(keyslist, valueslist))

D = dict.fromkeys(['name', 'age'])

D['name']
通过键索引
E['cto']['age']

'age' in D   
成员关系操作符
D.keys()
字典所有的键
D.values()
字典所有的值
D.items()
字典所有的键值
D.copy()
浅复制
D.clear()
删除所有的元素
D.update(D2)
合并字典
D.get(key, default)
得到值(如果不存在,则返回默认值)
D.pop(key, default)   
删除字典的值(如果哦不存在,则返回默认值)
D.setdefault(key, default)
设置元素的值(如果元素值存在,则不进行任何的修改,如果不存在,则新建key/default的键值)
D.popitem()
删除键值(具有随机性,因为键值本身存储并不是顺序存储的)
len(D)
字典的长度
D[key] = 42   
字典的赋值
del D[key]   
删除字典的元素(通过值)
list(D.keys())
使用list函数序列化字典的键
D1.keys() & D2.keys()

D.viewkeys(), D.viewvalues()

D = {x: x * 2 for x in range(10)}

Dictionaries in Action

    我们一般使用键值来读取数组:

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D['spam']
2
    使用len函数来读取字典的长度,in来判断成员关系,而我们一般也使用keys()来读取出所有的键来进行操作.

>>> len(D)
3
>>> 'ham' in D
True
>>> list(D.keys())
['eggs', 'ham', 'spam']
    一般情况下我们可以使用赋值的方式给字典新增键/值,但是如果存在如下的情况:如果键存在,则我们不插入;否则,插入.我们就不应该直接赋值,可以使用setdefault方法

>>> D = {'eggs': 3, 'spam': 2, 'ham': 1}
>>> D['ham'] = ['grill', 'bake', 'fry']
>>> D
{'eggs': 3, 'ham': ['grill', 'bake', 'fry'], 'spam': 2}
>>> del D['eggs']
>>> D
{'ham': ['grill', 'bake', 'fry'], 'spam': 2}
>>> D.setdefault('spam', 3)
2
>>> D
{'ham': ['grill', 'bake', 'fry'], 'spam': 2}
>>> D.setdefault('eggs', 3)
3
>>> D
{'eggs': 3, 'ham': ['grill', 'bake', 'fry'], 'spam': 2}
    我们可以使用values()来读取所有的值,而通过items()来获取所有的键值:

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> list(D.values())
[3, 1, 2]
>>> list(D.items())
[('eggs', 3), ('ham', 1), ('spam', 2)]
    如果键不存在,则我们读取会出现错误.这时候我们需要使用get函数:

>>> D.get('spam')
2
>>> D.get('toast')	//这里返回None
>>> D.get('toast', 88)
88
    我们可以使用update方法来更新一个字典:

>>> D
{'eggs': 3, 'ham': 1, 'spam': 2}
>>> D2 = {'toast': 4, 'muffin': 5}
>>> D.update(D2)
>>> D
{'toast': 4, 'muffin': 5, 'eggs': 3, 'ham': 1, 'spam': 2}
    字典也可以使用pop函数来删除键/值,或者使用del也不错:

>>> D.pop('muffin')
5
>>> D.pop('muffin')

Traceback (most recent call last):
  File "<pyshell#60>", line 1, in <module>
    D.pop('muffin')
KeyError: 'muffin'
>>> del D['toast']
>>> del D['toast']

Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    del D['toast']
KeyError: 'toast'
>>> D
{'eggs': 3, 'ham': 1, 'spam': 2}
    所以,在删除字典键值之前,一定要判断键是否存在(通过in实现):

>>> D
{'eggs': 3, 'ham': 1, 'spam': 2}
>>> if 'eggs' in D:
	del D['eggs']

	
>>> D
{'ham': 1, 'spam': 2}
>>> if 'eggs' in D:
	del D['eggs']

	
>>> D
{'ham': 1, 'spam': 2}



使用字典需要注意的地方:
1. 序列的操作通常不适合字典使用:因为字典是哈希结构的,所以类似序列的连接,切片操作均不适合.
2. 赋值操作总会新建一个键/值:对于字典来说,赋值操作会新建一个键/值,所以如果不想要这样,则可以使用setdefault方法,配合in成员关系操作实现.
3. 键并不总是字符串:只要是可哈希的值,均可以作为键,如:数字,字符串,元组.
    对于键不存在的字典,我们读取数据会报错.这时候可以使用三种方法来避免错误:1.使用in操作符来判断键是否存在. 2.使用try...except来捕捉异常.3.通过get方法来读取数据(无键则返回None)

共有 人打赏支持
粉丝 363
博文 209
码字总数 447144
×
fzyz_sb
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: