【Python3 初级篇】1. 数据类型：列表、元组、字符串、字典、集合

---

0. 环境

硬件信息：
CPU：Intel® Core™ i5-9400F CPU @ 2.90GHz
内存：32GB
硬盘：三星970evo 500GB

Python 版本：
3.6.9

系统版本：
Ubuntu 18.04.2 LTS (Bionic Beaver)

参考地址：
廖雪峰 - python基础
菜鸟教程 - Python3 基础语法
【Python 基础教程（第3版） [挪] Magnus Lie Hetland 著】

---

1. 基础语法

注释：
在代码中，单行注释以 # 开头，# 后面到行尾的所有内容都将被忽略。

#!/usr/bin/python3
 
# 第一个注释
print ("Hello, Python!") # 第二个注释

多行注释可以用多个 # 号，还有 ''' 和 """：

#!/usr/bin/python3
 
# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")

多行语句：
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠\来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠\，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

---

2. 输出与输入

2.1 print() 输出

print() 函数可以打印一个或多个字符串。多个字符串之间用逗号,隔开，print()会依次打印每个字符串，遇到逗号,会输出一个空格：

>>> print('The quick brown fox', 'jumps over', 'the lazy dog')
The quick brown fox jumps over the lazy dog

如果需要，可自定义分隔符：

>>> print("I", "wish", "to", "register", "a", "complaint", sep="_")
I_wish_to_register_a_complaint

print()也可以打印整数，或者计算结果：

>>> print("1024 * 768 =",1024*768)
1024 * 768 = 786432

print() 默认输出自带换行符，相当于print(STR, end="\n")。
如果要实现不换行则可以写成print(STR, end="")。
当然也可以通过 end=参数实现其他效果：

#!/usr/bin/env python3
# 不换行输出
print( 'a', end="" )
print( 'b' )

print('-'*8)
# 间隔 8 个空格输出
print( 'a', end="\t" )
print( 'b' )

输出结果：

ab
--------
a       b

2.2 input() 输入

input()内置函数从标准输入读入一行文本，默认的标准输入是键盘。
用户输入内容被 input 以 字符串 方式返回。

>>> x = input("x: ")
x: 34
>>> y = input("y: ")
y: 42
>>> print(int(x) * int(y))
1428

---

3. 数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Python支持多种数据类型，在计算机内部，可以把任何数据都看成一个“对象”，而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来。
对变量赋值x = y是把变量x指向真正的对象，该对象是变量y所指向的。随后对变量y的赋值不影响变量x的指向。

对于不可变数据的任何更改，都会生成新的数据，因此在使用赋值x=y语句后，修改其中一个变量，不会影响另一个变量的值：

>>> a='a'
>>> b=a
>>> a=a+'b'  # 执行 a+'b' 后的结果为一个新的字符串，并将此字符串赋值给变量 a
>>> a
'ab'
>>> b
'a'

对于可变数据的很多修改，只会修改原始数据，因此在x=y赋值后，修改一个变量，另一个也会受影响：

>>> a = [1,2,3]
>>> b = a
>>> a.append(4) # 执行结果只是在原列表中修改
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3, 4]

3.1 数字

整数：
与数学上的写法样，如：1，100，-8080，0。
可用不同的进制表示，如十六进制的0xff00，0xa5b4c3d2。

浮点数：
可以用数学写法，如1.23，3.14，-9.01。
对于很大或很小的浮点数，用科学计数法表示，把 10 用 e 替代，1.23x10⁹ 就是1.23e9或者12.3e8，0.000012可以写成1.2e-5，等等。

复数：
略过

数值运算：

>>>5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 浮点除，得到一个浮点数
0.5
>>> 2 // 4 # 整除，向下取整，输出的数据类型与分子分母数据类型有关
0
>>> -10//3 # -10/3=-3.3333……，向下取整即为 -4
-4
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 17 % 3 # 取余 ，负数取余为先计算整除结果，再计算出余数。即 x % y 等价于 x - ((x // y) * y)。
2
>>> 10 % 3
1
>>> 10 % -3 # 先计算 10//-3=-4，再计算(-4)*(-3)=12，最后计算 10-12=-2。
-2
>>> -10 % 3
2
>>> -10 % -3
-1
>>> 2 ** 5 # 乘方
32

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确，浮点数运算则可能会有四舍五入的误差。

3.2 字符串

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等。
如果字符串里面既包含'又包含"，用转义字符\标记。
此外\可以转义很多字符，比如\n表示换行，\t表示制表符
为了简化，Python还允许用r''表示''内部的字符串默认不转义，可以自己试试：

>>> print('\\\t\\')
\       \
>>> print(r'\\\t\\')
\\\t\\

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容，可以自己试试：

>>> print('''line1
... line2
... line3''')
line1
line2
line3

---

4. 序列（sequence）

4.1 序列概述

序列(sequence)：成员是有序排列的，并且可以通过序号，即索引，访问其中一个或者几个成员。包括：

• 元组(tuple)：不可修改，使用()；
• 列表(list)：可修改，使用[]
• 字符串：不可修改，使用引号

容器(container)：可包含其他对象的对象。包括：

• 序列
• 映射：字典(dict)
• 集合(set)

4.2 通用序列操作

包括：索引(indexing)、切片(sliceing)、加(adding)、乘(multiplying)、成员资格、计算长度、找出最大最小元素

1. 索引：

>>>greeting = 'Hello' 
>>>greeting[0]
'H'

2. 切片：

>>>numbers = [1,2,3,4,5,6,7,8,9,10]
>>>numbers[3:6]
[4,5,6]
>>>numbers[0:1]
[1]
>>> numbers[-3:]
[8, 9, 10]
>>> numbers[:3]
[1, 2, 3]

3. 序列相加:

>>>[1,2,3]+[4,5,6]
[1,2,3,4,5,6]

注意：两种相同类型的序列才能进行连接操作

4. 乘法

>>>'python' * 5
'pythonpythonpythonpyhtonpython'
>>>[42] * 3
[42,42,42]

5. 成员资格

>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
>>> users = ['mlh', 'foo', 'bar']
>>> input('Enter your user name: ') in users
Enter your user name: mlh
True
>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject
True

注意：从2.3开始，in可以做字符串成员检查

6. 长度、最小值、最大值

>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34

---

5. 列表（list）

5.1 基本列表操作

• 赋值：x[1] = 2
• 删除：del names[2] del numbers[1:4]
• 切片：name[x:y]
• 切片插入和删除：

>>> alpha = ['a','e']
>>> alpha[1:1]	# 直接查看则为空列表
[]
>>> alpha[1:1] = ['b','c','d']	# 进行赋值相当于在此位置进行插入操作
>>> alpha
['a', 'b', 'c', 'd', 'e']
>>> alpha[1:4] = []	# 若赋值为空则相当于删除操作
>>> alpha
['a', 'e']

5.2 列表方法

1. append()：用于将一个对象附加到列表末尾。

>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

2. clear()：清空列表的内容。lst.clear() 等同于 lst[:] = []。
3. copy()：复制列表，相当于 lst2 = lst1[:]。此为浅拷贝，只拷贝父对象，不会拷贝对象的内部的子对象。详见：Python 直接赋值、浅拷贝和深度拷贝解析

>>> a = [1,2,[1,2,3]]
>>> b = a.copy()
>>> a, b
([1, 2, [1, 2, 3]], [1, 2, [1, 2, 3]])
>>> a.append(3)
>>> a, b
([1, 2, [1, 2, 3], 3], [1, 2, [1, 2, 3]])
>>> a[2].append(4)
>>> a, b
([1, 2, [1, 2, 3, 4], 3], [1, 2, [1, 2, 3, 4]])

深度拷贝需要引入 copy 模块：

>>>import copy
>>> c = copy.deepcopy(a)
>>> a, c
({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
>>> a[1].append(5)
>>> a, c
({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})

4. count()：计算指定的元素在列表中出现了多少次。
5. extend()：在列表末尾追加另一个列表，修改的是被扩展的序列。使用 + 拼接返回的是新序列。因此a.extend(b) 拼接效率高于 a = a + b。
6. index()：在列表中查找指定值第一次出现的索引。
7. insert()：用于将一个对象插入列表。

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

8. pop()：从列表中删除一个元素（默认为最后一个元素），并返回这一元素。

>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]

备注：pop是唯一既修改列表又返回一个非None值的列表方法。因此 pop 方法和 append 方法可实现一种常见的数据结构——栈（stack），后进先出（LIFO）。

9. remove()：用于移除列表中某个值的第一个匹配项，不返回任何值。

>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']

10. reverse()：按相反的顺序排列列表中的元素，直接修改原列表，不返回任何值。

>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]

备注：如果要按相反的顺序迭代序列，可使用函数 reversed。这个函数不返回列表，而是返回一个迭代器。可使用list将返回的对象转换为列表。

>>> x = [1, 2, 3]
>>> list(reversed(x))
[3, 2, 1]

11. sort()：修改原列表，不返回任何值。 sorted() 函数可用于任何可迭代的对象，但总是返回一个列表。

>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x.sort() # Don't do this!
>>> print(y)
None
>>> x
[1, 2, 4, 6, 7, 9]
# 若需要排序后的列表副本并保留原始列表不变时：
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x.copy()
>>> y.sort()
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]
# 或：
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

12. sort() 和 sorted() 接受两个可选参数：key和reverse。
    key：设置一个用于排序的函数。使用此函数为每个元素创建一个
    键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。

>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

reverse：只需将其指定为True或False，以指出是否要按相反的顺序对列表进行排序。

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]

13. remove(),pop(),del() 删除列表元素的区别：

• remove() ：删除单个元素，删除首个符合条件的元素，按值删除，返回值为空
• pop()：删除索引位置元素，无参情况下删除最后一个元素，返回删除的元素值
• del()：根据索引位置来删除单个值或指定范围内的值，另外del可以删除整个数据对象(列表、集合等)，但此时删除引用(变量)而不是删除对象(数据)，对象由自动垃圾回收机制（GC）删除。

详细可见：python删除列表元素remove,pop,del

---

6. 元组（tuple）

只要将一些值用逗号分隔，就能自动创建一个元组。

>>> 3 * (40 + 2)
126
>>> 3 * (40 + 2,)
(42, 42, 42)

• tuple()：将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。

>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)

• list()：将元组或者字符串转成序列

---

7. 字符串（string）

7.1 常见字符串方法

1. center() 通过在两边添加填充字符（默认为空格）让字符串居中。

>>> "The Middle by Jimmy Eat World".center(39)
'     The Middle by Jimmy Eat World     '
>>> "The Middle by Jimmy Eat World".center(39, "*")
'*****The Middle by Jimmy Eat World*****'

2. find() 在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回 -1。同时可指定搜索的起点和终点。

>>> 'With a moo-moo here, and a moo-moo there'.find('moo')
7
>>> title = "Monty Python's Flying Circus"
>>> title.find('Monty')
0
>>> title.find('Zirquss')
-1

>>> subject = '$$$ Get rich now!!! $$$'
>>> subject.find('$$$', 1) # 只指定了起点
20
>>> subject.find('!!!')
16
>>> subject.find('!!!', 0, 16) # 同时指定了起点和终点，包含起点但不包含终点
-1

3. join() 用于合并序列的元素，其作用与split相反。

>>> seq = ['1', '2', '3', '4', '5']
>>> sep = '+'
>>> sep.join(seq) # 合并一个字符串列表
'1+2+3+4+5'
>>> dirs = '', 'usr', 'bin', 'env'
>>> '/'.join(dirs)
'/usr/bin/env'

4. split() 用于将字符串拆分为序列，其作用与join相反。

>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']
>>> '/usr/bin/env'.split('/')
['', 'usr', 'bin', 'env']
>>> 'Using the default'.split()
['Using', 'the', 'default']

注意：如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符等）处进行拆分。

5. strip() 将字符串开头和末尾的空白字符或者指定字符删除，并返回删除后的结果。

>>> '   internal whitespace is kept   '.strip()
'internal whitespace is kept'

>>> '*** SPAM * for * everyone!!! ***'.strip(' *!')
'SPAM * for * everyone'

6. replace() 将指定子串都替换为另一个字符串，并返回替换后的结果。

>>> 'This is a test'.replace('is', 'eez')
'Theez eez a test'

7. translate() 与 replace() 一样替换字符串的特定部分，但不同的是它只能进行单字符替换。这个方法的优势在于能够同时替换多个字符，因此效率比replace高。

>>> table = str.maketrans('cs', 'kz')
>>> 'this is an incredible test'.translate(table)
'thiz iz an inkredible tezt'

8. lower() 返回字符串的小写版本，upper() 返回字符串的大写版本。

>>> 'Trondheim Hammer Dance'.lower()
'trondheim hammer dance'
>>> 'abc'.upper()
'ABC'

7.2 % 格式化

在Python中，采用的格式化方式和C语言是一致的，用%实现。在%左边指定一个格式字符串，并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值（如字符串或数字），也可使用元组或字典。举例如下：

>>> 'Hello, %s' % 'world'
'Hello, world'

>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

>>> format = "Hello, %s. %s enough for ya?"
>>> values = ('world', 'Hot')
>>> format % values
'Hello, world. Hot enough for ya?'

在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

常见的占位符有：

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

符号	功能
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
-	用做左对齐
+	在正数前面显示加号( + )
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
示例如下：

>>> print('%2d-%02d' % (3, 1))
 3-01
>>> print('%.2f' % 3.1415926)
3.14 

如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：

>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'

用%%来表示一个%：

>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'

7.3 format() 格式化

在最简单的情况下，替换字段没有名称或将索引用作名称，索引也可不按顺序排列。

>>> "{}, {} and {}".format("first", "second", "third")
'first, second and third'
>>> "{0}, {1} and {2}".format("first", "second", "third")
'first, second and third'
>>> "{3} {0} {2} {1} {3} {0}".format("be", "not", "or", "to")
'to be or not to be'

在Python 3.6中，如果变量与替换字段同名，还可使用一种简写。在这种情况下，可使用f字符串：

>>> from math import e
>>> f"Euler's constant is roughly {e}."
"Euler's constant is roughly 2.718281828459045."

与以下 format 写法等价：

>>> "Euler's constant is roughly {e}.".format(e=e)
"Euler's constant is roughly 2.718281828459045."

格式说明符 : 后面的表达式可指定最终的输出格式，包括格式类型，字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。

格式类型	含义
b	将整数表示为二进制数
d	将整数视为十进制数进行处理，这是整数默认使用的说明符
e	使用科学表示法来表示小数（用e来表示指数）
f	将小数表示为定点数
g	自动在定点表示法和科学表示法之间做出选择
s	保持字符串的格式不变，这是默认用于字符串的说明符
%	将数表示为百分比值

>>> "{pi:10.2f}".format(pi=pi)
'      3.14'
>>> '{:010.2f}'.format(pi)
'0000003.14'

要指定左对齐、右对齐和居中，可分别使用<、>和^。注意：- 在 format 方法中没有左对齐的功能。

>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi))
3.14
   3.14
     3.14

可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。

>>> "{:#^15}".format("WIN BIG")
'####WIN BIG####'

显示正数和负数：

>>> print('{0:-.2}\n{1:-.2}'.format(pi, -pi)) #默认设置
3.1
-3.1
>>> print('{0:+.2}\n{1:+.2}'.format(pi, -pi))
+3.1
-3.1
>>> print('{0: .2}\n{1: .2}'.format(pi, -pi))
 3.1
-3.1

对于数字格式化，更详细的内容可以参考：Python format 格式化函数

---

8. 字典（dict）

通过名称来访问其各个值的数据结构。这种数据结构称为 映射（mapping）。
字典（dict） 是 Python 中唯一的内置映射类型。在其他语言中也称为 map，使用键-值（key-value）存储，具有极快的查找速度。

dict() 方法从其他映射（如其他字典）或键-值对序列创建字典。

>>> items = [('name', 'Gumby'), ('age', 42)]
>>> d = dict(items)
>>> d
{'age': 42, 'name': 'Gumby'}
>>> d['name']
'Gumby'

还可使用关键字实参来调用这个函数，如下所示：

>>> d = dict(name='Gumby', age=42)
>>> d
{'age': 42, 'name': 'Gumby'}

8.1 基本的字典操作

字典的基本行为在很多方面都类似于序列：

• 获取长度： len(d) 返回字典d包含的项（键-值对）数。
• 查询： d[k] 返回与键 k 相关联的值。
• 赋值： d[k] = v 将值 v 关联到键 k。 即使是字典中没有的键，也可以赋值，相当于新增。
• 删除： del d[k] 删除键为 k 的项。
• 检查成员资格： k in d 检查字典 d 是否包含键为 k 的项。

8.2 将字符串格式设置功能用于字典

>>> phonebook
{'Beth': '9102', 'Alice': '2341', 'Cecil': '3258'}
>>> "Cecil's phone number is {Cecil}.".format_map(phonebook)
"Cecil's phone number is 3258."

>>> template = '''<html>
... <head><title>{title}</title></head>
... <body>
... <h1>{title}</h1>
... <p>{text}</p>
... </body>'''
>>> data = {'title': 'My Home Page', 'text': 'Welcome to my home page!'}
>>> print(template.format_map(data))
<html>
<head><title>My Home Page</title></head>
<body>
<h1>My Home Page</h1>
<p>Welcome to my home page!</p>
</body>

8.3 字典方法

1. clear() 删除所有的字典项，无返回值。
2. copy() 返回一个新字典，其包含的键-值对与原来的字典相同，同样是浅拷贝。

>>> from copy import deepcopy
>>> d = {}
>>> d['names'] = ['Alfred', 'Bertrand']
>>> c = d.copy()
>>> dc = deepcopy(d)
>>> d['names'].append('Clive')
>>> c
{'names': ['Alfred', 'Bertrand', 'Clive']}
>>> dc
{'names': ['Alfred', 'Bertrand']}

3. fromkeys() 创建一个新字典，其中包含指定的键，且每个键对应的值都是 None。

>>> {}.fromkeys(['name', 'age'])
{'age': None, 'name': None}

>>> dict.fromkeys(['name', 'age'])
{'age': None, 'name': None}

>>> dict.fromkeys(['name', 'age'], '(unknown)')
{'age': '(unknown)', 'name': '(unknown)'}

4. get() 可获取不存在的键。

>>> d = {}
>>> print(d['name'])
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: 'name'
>>> print(d.get('name'))
None
>>> d.get('name', 'N/A') #可指定“默认”值，这样将返回你指定的值而不是None。
'N/A'
>>> d['name'] = 'Eric'
>>> d.get('name')
'Eric'

6. keys() 返回字典中所有键字典视图。返回的是一个迭代器，可以使用 list() 来转换为列表。

>>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0}
>>> d.keys()
dict_keys(['title', 'url', 'spam'])
>>> list(d.keys())
['title', 'url', 'spam']

11. values() 返回一个由字典中的值组成的字典视图。返回的是一个迭代器，可以使用 list() 来转换为列表。

>>> d = {}
>>> d[1] = 1
>>> d[2] = 2
>>> d[3] = 3
>>> d[4] = 1
>>> d.values()
dict_values([1, 2, 3, 1])
>>> list(d.values())	 
[1, 2, 3, 1]

5. items() 返回一个包含所有字典项的列表，其中每个元素都为(key, value)的形式。字典项在列表中的排列顺序不确定。返回的是一个迭代器，可以使用 list() 来转换为列表。

>>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0}
>>> d.items()
dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])
>>> list(d.items())
[('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)]

返回值属于一种名为字典视图的特殊类型。字典视图可用于迭代,确定其长度以及对其执行成员资格检查。视图的一个优点是不复制，它们始终是底层字典的反映，即便你修改了底层字典亦如此。

>>> it = d.items()
>>> len(it)
3
>>> ('spam', 0) in it
True
>>> d['spam'] = 1
>>> ('spam', 0) in it
False
>>> d['spam'] = 0
>>> ('spam', 0) in it
True

7. pop 可用于获取与指定键相关联的值，并将该键-值对从字典中删除。

>>> d = {'x': 1, 'y': 2}
>>> d.pop('x')
1
>>> d
{'y': 2}

8. popitem 随机弹出一个字典项。

>>> d = {'url': 'http://www.python.org', 'spam': 0, 'title': 'Python Web Site'}
>>> d.popitem()
('url', 'http://www.python.org')
>>> d
{'spam': 0, 'title': 'Python Web Site'}

9. setdefault 获取与指定键相关联的值，若不包含指定的键时，在字典中添加指定的键-值对。

>>> d = {}
>>> d.setdefault('name', 'N/A')
'N/A'
>>> d
{'name': 'N/A'}
>>> d['name'] = 'Gumby'
>>> d.setdefault('name', 'N/A')
'Gumby'
>>> d
{'name': 'Gumby'}

10. update 使用一个字典中的项来更新另一个字典。不返回任何值。

>>> d = {
... 'title': 'Python Web Site',
... 'url': 'http://www.python.org',
... 'changed': 'Mar 14 22:09:15 MET 2016'
... }
>>> x = {'title': 'Python Language Website'}
>>> n = d.update(x)	# 不返回任何值，或者说返回的是 None
>>> n
None
>>> d
{'url': 'http://www.python.org', 'changed':
'Mar 14 22:09:15 MET 2016', 'title': 'Python Language Website'}

和 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'

---

9. 集合（set）

集合（set）是一个无序的不重复元素序列。可以使用大括号 {} 或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是{}，因为 {} 是用来创建一个空字典。

两个集合间的运算：

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

集合内置方法列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
discard()	删除集合中指定的元素，不存在不会报错
pop()	随机移除元素
remove()	移除指定元素
update()	给集合添加元素

方法示例：

>>>a = {x for x in 'abracadabra' if x not in 'abc'} #集合推导式，同列表推导式
>>> a
{'r', 'd'}

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

---

10. 练习

1. 请打印出以下变量的值：

# -*- coding: utf-8 -*-
n = 123
f = 456.789
s1 = 'Hello, world'
s2 = 'Hello, \'Adam\''
s3 = r'Hello, "Bart"'
s4 = r'''Hello,
Lisa!'''

解答：

123
456.789
Hello, world
Hello, 'Adam'
Hello, "Bart"
Hello,
Lisa!

2. 小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出’xx.x%'，只保留小数点后1位：
   解答：

#!/usr/bin/python3
s1 = 72
s2 = 85
r = (s2-s1)/s1
print("score has improved {:.1%}".format(r))

输出结果：

score has improved 18.1%

3. 请用索引取出下面list的指定元素：

# -*- coding: utf-8 -*-

L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]

# 打印Apple:
print(L[0][0])
# 打印Python:
print(L[1][1])
# 打印Lisa:
print(L[2][2])

4. 小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，并根据BMI指数：

   低于18.5：过轻
   18.5-25：正常
   25-28：过重
   28-32：肥胖
   高于32：严重肥胖
   用if-elif判断并打印结果：

# -*- coding: utf-8 -*-
height = 1.75
weight = 80.5
bmi = 80.5/1.75**2
print(bmi)
if bmi < 18.5:
    print("过轻")
elif 18.5 <= bmi < 25:
    print("正常")
elif 25 <= bmi < 28:
    print("过重")
elif 28 <= bmi < 32:
    print("肥胖")
else:
    print("严重肥胖")

运行结果：

26.285714285714285
过重