5.2. del 语句 5.3. 元组和序列 5.4. 集合 5.5. 字典

有个方法可以从列表中按给定的索引而不是值来删除一个元素：del语句。它不用于有返回值的pop()方法。语句del还可以从列表中删除切片或清空整个列表(我们之前介绍过一个方法是将控列表赋值给列表的切片)。例如:

a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]
a

[1, 66.25, 333, 333, 1234.5]

del a[2:4]
a

[1, 66.25, 1234.5]

del a[:]
a

[]

del也可以删除整个变量:

del a
a

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-5-88f0dc819981> in <module>()
      1 del a
----> 2 a


NameError: name 'a' is not defined

此后再引用变量a就会引发错误(直到再赋给它一个值为止)。我们在后面的内容中可以看到del的其他用法。

5.3.元组和序列

我们直到列表和字符串有很多通用的属性，例如索引和切割操作。它们属于序列类型。因为Python是一个不断在进化的语言，也可能会加入其他的序列类型，这里介绍另一种标准序列类型：元组

一个元组由数个逗号分割的值组成：

t = 12345, 54321, 'hello!'
t[0]

12345

t

(12345, 54321, 'hello!')

#元组也可以嵌套
u = t, (1, 2, 3, 4, 5)
u

((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

#元组是不可变的
t[0] = 88888

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-11-d13c47e318e9> in <module>()
      1 #元组是不可变的
----> 2 t[0] = 88888


TypeError: 'tuple' object does not support item assignment

v = ([1, 2, 3], [3, 2, 1])
#但它可以包含可变对象，比如列表
v[0][1] = 5
v

([1, 5, 3], [3, 2, 1])

如你所见， 元组在输出时总是右括号的，以便于正确表达嵌套结构。在定义时可以有括号或没括号，不过一般来说括号都是必须的（如果它是一个更大表达式的一部分时）。不能给元组一的一个独立元素赋值(尽管你可以通过连接和切割来模拟这个行为)。还可以创建包含可变对象的元组，比如列表。

虽然元组和列表很类似，它们经常被用在不同的情况和不同的用途上。元组有很多用途，例如(x, y)坐标对，数据库中的员工记录等。元组就像字符串，是不可变的。通常包含不同种类的元素并通过分拆或索引来访问(如果是namedtuples，甚至可以通过属性访问)。列表是可变的，它们的元素通常是相同类型的，并通过迭代访问。

一个特殊的问题是构造包含零个或一个元素的元组：为了适应这种情况，语法上有一些额外的改变。一对空括号可以创建空元组；要创建一个单元素元组可以在值后面跟一个逗号(在括号中放入一个单值不够明确)。这不好看，但是有效。例如：

empty = ()
singleton = 'hello',  #<--逗号使之成为一个元组
print(len(empty))
print(len(singleton))
singleton

0
1





('hello',)

语句t = 12345, 54321, 'hello!'是元组封装的一个例子：值12345,54321和hello!被封装进元组。其逆操作可能是这样：

x, y, z = t
print(x, y, z)

12345 54321 hello!

这个调用等号右边可以是任何线性序列，称之为序列拆封非常恰当。序列拆封要求左侧的变量数目与序列的元素个数相同。要注意的是多重赋值(multiple assignment)其实只是元组封装和序列拆封的一个结合。

5.4.集合

Python还包含了一个数据类型–set(集合)。集合是一个无序且不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持union(联合),intersection(交),difference(差)和sysmmetric difference(对称差集)等数学运算。

大括号或set()函数可以用来定义集合。注意:想要定义空集合，你必须使用set()而不是{}。后者用于创造空字典，我们在下一节会介绍字典。

以下是一个简单的演示：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)

{'banana', 'orange', 'apple', 'pear'}

'orange' in basket

True

'crabgrass' in basket

False

a = set('abracadabra')
b = set('alacazam')
a

{'a', 'b', 'c', 'd', 'r'}

a = {'abracadabra'} 
a
a = set('apple','banana') 
a
# 这里说集合函数只接收一个参数，从这里可以看出用大括号和set()函数的区别

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-24-12be3817e9cb> in <module>()
      1 a = {'abracadabra'}
      2 a
----> 3 a = set('apple','banana')
      4 a


TypeError: set expected at most 1 arguments, got 2

a = set('abracadabra')
print(a)
print(b)

{'c', 'b', 'd', 'r', 'a'}
{'c', 'z', 'm', 'l', 'a'}

a - b #在a中不在b中的元素

{'b', 'd', 'r'}

a | b #在a或者b中的元素

{'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'}

a & b #不但在a也在b中的元素

{'a', 'c'}

a ^ b #在a或b中，但不同时存在的元素

{'b', 'd', 'l', 'm', 'r', 'z'}

类似列表推导式，这里由一种集合推导式语法:

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
b = [x for x in 'abracafabra' if x not in 'abc']
print(b)

{'r', 'd'}
['r', 'f', 'r']

#忽然想起一个清除列表中相同元素的方法
temp_set = set(b)
b = [x for x in temp_set]
print (b)

['r', 'f']

5.5.字典

另一个非常有用的Python内建数据类型是字典。字典在某些语言中可能称为associative memories或者associative arrays。序列是以连续的整数为索引，与此不同的字典是以关键字为索引，关键字是任意不可变类型，通常用字符串或数值。如果元组中只包含字符串和数字，那它也可以作为关键字。如果它直接或简介地包含了可变对象，就不能当做关键字。不能用列表做关键字，因为列表可以改变。

理解字典的最佳方式是把它看做无序的键:值对(key:value对)集合，键必须是互不相同的(在一个字典之内)。一对大括号创建一个空的字典:{}。初始化列表时，在大括号内放置一组key:value对，这也是字典输出的方式。

字典的主要操作是依据键来存储和析取值。也可以用del来删除key:value对。如果你用一个已经存在的关键字存储值，以前为该关键字分配的值就会被替代。试图从一个不存在的键中取值会报错。

对一个字典执行list(d.key()) 将返回一个字典中所有关键字组成的无序列表(如果你想要排序，只需使用sorted(d.keys())。使用python的in关键字，可以检测字典中是否存在某个关键字。

这里是字典的一个小示例：

tel = {'jack': 4098, 'sape': 4139} #用大括号直接定义字典
tel['guido'] = 4127 #用中括号来为字典添加key:value对
print(tel)
print(tel['jack']) #通过key索引value

{'jack': 4098, 'sape': 4139, 'guido': 4127}
4098

del tel['sape']
tel['irv'] = 4127
print(tel)
#把字典的关键字们转化为列表
print(list(tel.keys()))
#把关键字列表排序
print(sorted(tel.keys()))
#这里可以发现，sorted函数可以直接将dict_keys转化为列表
print(type(sorted(tel.keys())))
print(type(tel.keys()))

{'jack': 4098, 'guido': 4127, 'irv': 4127}
['jack', 'guido', 'irv']
['guido', 'irv', 'jack']
<class 'list'>
<class 'dict_keys'>

print('guido' in tel)
print('jack' not in tel)

True
False

dict()构造函数可以直接从key\value 对中创造字典:

dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])

{'sape': 4139, 'guido': 4127, 'jack': 4098}

此外，字典推导式可以从任意的键值表达式中创建字典：

{x: x ** 2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}

如果关键字都是简单的字符串，有时通过关键字参数指定key-value对更为方便：

dict(sape=4139, guido = 4127, jaca = 4098)

{'sape': 4139, 'guido': 4127, 'jaca': 4098}

5.6.循环技巧

在字典中循环时，关键字和对应的值可以使用item()方法同时解读出来:

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
print (knights.items)
print (type(knights.items))
for k, v in knights.items():
    print(k, v)

<built-in method items of dict object at 0x7f8d9c6d6048>
<class 'builtin_function_or_method'>
gallahad the pure
robin the brave

在序列中循环时，索引位置和对应值可以使用enumerate()函数同时得到：

for i, v in enumerate(['tic', 'tac', 'toe']):
    # i是索引位置
    # v是对应元素
    print(i, v)

0 tic
1 tac
2 toe

#试一试元组和集合
temp_tuple = 'tic', 'tac', 'toe'
temp_set = set(temp_tuple)
for i ,v in enumerate(temp_tuple):
    print(i, v)
for i ,v in enumerate(temp_set):
    print(i, v)

0 tic
1 tac
2 toe
0 tic
1 toe
2 tac

同时循环两个或更多的序列，可以使用zip()整体打包:

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
print(type(zip(questions, answers)))
for q, a in zip(questions, answers):
    print('What is your {0}? It is {1}'.format(q, a))

<class 'zip'>
What is your name? It is lancelot
What is your quest? It is the holy grail
What is your favorite color? It is blue

需要逆向循环序列的话，先正向定位序列，然后调用reversed()函数:

for i in reversed(range(1, 10 ,2)):
    print(i)

9
7
5
3
1

要按排序后的顺序循环序列的话，使用sorted()函数，它不改动原序列，而是生成一个新的已排序的序列：

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
    print(f)

apple
banana
orange
pear

若要在循环内部修改正在遍历的序列(例如复制某些元素),建议首先制作副本。在序列上循环不会隐式地创建副本。切片表示法使这尤其方便：

words = ['cat', 'window', 'defenestrate']
for w in words[:]: #遍历一个副本
    if len(w) > 6:
        words.insert(0, w)
words

['defenestrate', 'cat', 'window', 'defenestrate']