python元组与字典

Posted 2020-09-15

元组及字典

目录：

  1、元组

  2、字典

  3、字典的一些使用方法

一、元组

1、元组概念：

  元组：（tuple），有序列表叫元组，tuple和list非常类似，但是list列表可以修改元素，而元组是无法修改定义好的元素的。

  元组使用（）定义。

例：

  >>> classmates = (‘Michael‘, ‘Bob‘, ‘Tracy‘)

  现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

 

如果要定义一个空的tuple，可以写成()：

>>> t = ()

>>> t

()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

>>> t = (1)

>>> t

1

  定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

  所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> t = (1,)

>>> t

(1,)

  Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

  2）、最后来看一个“可变的”tuple：

>>> t = (‘a‘, ‘b‘, [‘A‘, ‘B‘])

>>> t[2][0] = ‘X‘

>>> t[2][1] = ‘Y‘

>>> t

(‘a‘, ‘b‘, [‘X‘, ‘Y‘])

  这个tuple定义的时候有3个元素，分别是‘a‘，‘b‘和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

  我们先看看定义的时候tuple包含的3个元素：

  当我们把list的元素‘A‘和‘B‘修改为‘X‘和‘Y‘后，tuple变为：

  表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向‘a‘，就不能改成指向‘b‘，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

  理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

元组方法：

a=(1,2,3,4,5,6,1,2,3,1,5,1)

count

a.count(1)

index

a.index(5)

2、字典

  Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

  字典使用{}定义

举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

names = [‘Michael‘, ‘Bob‘, ‘Tracy‘]

scores = [95, 75, 85]

  给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。

  如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

>>> d = {‘Michael‘: 95, ‘Bob‘: 75, ‘Tracy‘: 85}

>>> d[‘Michael‘]

95

  为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

  第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

  dict就是第二种实现方式，给定一个名字，比如‘Michael‘，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。

  这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

>>> d[‘Adam‘] = 67

>>> d[‘Adam‘]

67

  由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> d[‘Jack‘] = 90

>>> d[‘Jack‘]

90

>>> d[‘Jack‘] = 88

>>> d[‘Jack‘]

88

如果key不存在，dict就会报错：

>>> d[‘Thomas‘]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: ‘Thomas‘

  要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

>>> ‘Thomas‘ in d

False

  二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get(‘Thomas‘)

>>> d.get(‘Thomas‘, -1)

-1

注意：返回None的时候Python的交互式命令行不显示结果。

 

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

 

>>> d.pop(‘Bob‘)

75

>>> d

{‘Michael‘: 95, ‘Tracy‘: 85}

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

  和list比较，dict有以下几个特点：

  1）、查找和插入的速度极快，不会随着key的增加而变慢；

  2）、需要占用大量的内存，内存浪费多。

而list相反：

  1）、查找和插入的时间随着元素的增加而增加；

  2）、占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

  dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

  这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

  要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

>>> key = [1, 2, 3]

>>> d[key] = ‘a list‘

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: ‘list‘

字典的使用方法：

1)、定义一个字典

a={‘a‘:1,‘b‘:2,‘c‘:3}

clear       a.clear()     ##删除字典中所有key和value值

copy        b=a.copy()    ##将a字典的元素赋值给b

fromkeys    {}.fromkeys([‘e‘,‘f‘,‘g‘])  ##只定义key值，（）中的内容可以来自于定义好的一个字典，或者一个列表，只定义key值，value值为none

例：

get         a.get(‘a‘)    ##根据key，得出value值

has_key     a.has_key(‘a‘)  ##判断是否存在key值

items       a.items()  ##以列表形式分组输出key，value值

iteritems      ##字典中的迭代器

d.next   ：无序输出列表中元素

iterkeys    a.iterkeys()    ##迭代器，只输出key值

itervalues  a.itervalues()   ##迭代器，输出value值

keys        a.keys()    #只输出key

pop         a.pop(‘a‘)  ##删除key和value，根据key删除

popitem     a.popitem()  ##随机删除key和value

setdefault  a.setdefault("f",‘None‘)   ##添加key值，value对应none，如果key存在，输出key的value

update      a.update()   

格式：

  a.update(b)  ##b是一个字典，将b字典添加到a字典中，如

如果要添加的字典中的key值与当前字典key存在，会覆盖value值，如

注：根据key决定是否覆盖。

 

values      a.values()  ##输出a字典中的所有value值

viewitems   a.viewitems()  ###分组列表形式显示key和value值

viewkeys    a.viewkeys()  ##列表形式显示所有的key

本文出自 “keep常明” 博客，请务必保留此出处http://keep88.blog.51cto.com/11829099/1920712