二、序列（列表和元组）
2.1 通用序列操作
两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。映射将在第4章详细讨论。有一种既不是序列也不是映射的容器，它就是集合（set），将在第10章讨论。
有几种操作适用于所有序列，包括索引、切片、相加、相乘和成员资格检查。（还有迭代）
2.1.1 索引
序列中的所有元素都有编号——从0开始递增。
2.1.2 切片
使用切片（slicing）来访问特定范围内的元素，切片时正值从左往右切（第一个切口在第一个数前），切片时负值从右往左切（第一个切口在最后一个数后），第一个索引包含在内，而第二个索引不包含在内。
>>> p = "0123456789"
>>> p[3:6]
'345'
>>> p[8:-3]
''
>>> p[4:-3]
'456'
#如果切片结束于序列末尾，可省略第二个索引。
>>> p[-3:]
'789'
#同样，如果切片始于序列开头，可省略第一个索引。
>>> p[:3]
'012'
>>> p[:]
'0123456789'
#步长为-3
#步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素
>>> p[::-3]
'9630'2.1.3 序列相加
可使用加法运算符来拼接序列。
#列表相加拼接
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
#字符串相加拼接
>>> 'Hello,' + 'world!'
'Hello,world!'
#不能拼接列表和字符串，一般不能拼接不同类型的序列
>>> [1,2,3]+"abc"
Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
[1,2,3]+"abc"
TypeError: can only concatenate list (not "str") to list
2.1.4 乘法
将序列与数x相乘时，将重复这个序列x次来创建一个新序列：
>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
2.1.5 成员资格
要检查特定的值是否包含在序列中，可使用运算符 in 。满足时返回 True ，
不满足时返回 False。
>>> 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
# 检查用户名和PIN码
database = [
['albert', '1234'],
['dilbert', '4242'],
['smith', '7524'],
['jones', '9843']
]
username = input('User name: ')
pin = input('PIN code: ')
if [username, pin] in database: print('Access granted')2.1.6 长度、最小值和最大值
内置函数 len 、 min 和 max ，其中函数 len 返回序列包含的元素个数，而 min 和 max 分别返回序列中最小和最大的元素。
>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>> max(2, 3)
3
>>> min(9, 3, 2, 5)
22.2 列表
2.2.1 list
鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表很有帮助。
为此，可使用函数（实际为类） list。可将任何序列（而不仅仅是字符串）作为 list 的参数。
#字符串转列表
>>> l1 = list("hello")
>>> l1
['h', 'e', 'l', 'l', 'o']
#列表转字符串
>>> ''.join(l1)
'hello'
>>> 'UUU'.join(l1)
'hUUUeUUUlUUUlUUUo'2.2.2 基本操作
1. 修改列表：给元素赋值，使用索引表示法给特定位置的元素赋值，如 x[1] = 2 ，注意 不能给不存在的元素赋值。
2.删除元素，使用 del 语句。
>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']3. 给切片赋值，可同时给多个元素赋值，可将切片替换为长度与其不同的序列，还可在不替换原有元素的情况下插入新元素。
>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']负
>>> num = [0,1,2,3,4,5,6,7,8,9,10]
>>> num[0:5] = [10,9,8,7,6]
>>> num
[10, 9, 8, 7, 6, 5, 6, 7, 8, 9, 10]
>>> num[-3:-1] = [2,3]
>>> num
[10, 9, 8, 7, 6, 5, 6, 7, 2, 3, 10]
>>> num[:-1]=[0]
>>> num
[0, 10]
>>> num[-1:] = [0]
>>> num
[10, 9, 8, 7, 6, 5, 6, 7, 2, 3, 0]
>>> num[6:-1]=[4,3,2,1]
>>> num
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
2.2.3 列表方法
方法是与对象（列表、数、字符串等）联系紧密的函数。通常，像下面这样调用方法：
object.method(arguments)
方法调用与函数调用很像，只是在方法名前加上了对象和句点（第7章将详细阐述方法到底是什么）。列表包含多个可用来查看或修改其内容的方法。
1. append，方法 append 用于将一个对象附加到列表末尾。
>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]2. clear，方法 clear 就地清空列表的内容。这类似于切片赋值语句 lst[:] = []
>>> lst = [1, 2, 3]
>>> lst.clear()
>>> lst
[]3. copy，方法 copy 复制列表。
>>> a = [1, 2, 3]
>>> b = a #b也指向a
>>> b[1] = 4 #b改变了a也变了
>>> a
[1, 4, 3]
>>> a = [1, 2, 3]
>>> b = a.copy() #b只是复制了a的内容
>>> b[1] = 4 #b改变并不影响a
>>> a
[1, 2, 3]
#b = a.copy()类似于使用a[:]或list(a)，都为复制a而不是指向a4. count，方法 count 计算指定的元素在列表中出现了多少次。
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2
>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
15. extend，方法 extend 能够同时将多个值即一个列表附加到原列表末尾。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]6. index，方法 index 在列表中查找指定值第一次出现的索引。
>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
>>> knights.index('who')
47. insert，方法 insert 用于将一个对象插入列表。
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]8. pop，方法 pop 从列表中删除一个元素（末尾为最后一个元素），并返回这一元素。pop 是唯一既修改列表又返回一个非 None 值的列表方法。
>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]9. remove，方法 remove 用于删除第一个为指定值的元素。
>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']10. reverse，方法 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，方法 sort 用于对列表就地排序 。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]
#需要排序后的列表副本并保留原始列表不变时，错误做法：
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x.sort() #sort（）并没有返回值
>>> print(y)
None
正确做法：
>>> y = x.copy() #先保存原列表副本
>>> y.sort()
>>> y = sorted(x) #或者使用sorted函数
12. 高级排序，方法 sort 接受两个可选参数： key 和 reverse 。key：排序规则（可以是自定义或者已有函数），reverse：是否要按相反顺序排序，（reverse = True/一个真值 反向排序）
#根据长度对元素进行排序，将参数key设置为函数len
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']
#反向排序：
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]2.3 元组
与列表一样，元组也是序列，唯一的差别在于元组是不能修改的（字符串也不能修改）。将一些值用逗号分隔，就能自动创建一个元组。
1、它们用作映射中的键（以及集合的成员），而列表不行。
2、有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们（需要使用元组没有的 index 和 count等方法时例外）。
一般而言，使用列表足以满足对序列的需求。
>>> 1,2
(1, 2)
>>> (1,2,3)
(1, 2, 3)
>>> () #空元组
()
>>> (1,) #单个元素元组
(1,)
>>> 1,
(1,)函数 tuple 的工作原理与 list 很像：它将一个序列作为参数，并将其转换为元组。如果参数
已经是元组，就返回本身 。
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)三、字符串
3.1.1 替换字段名
#将按顺序将字段和参数配对
>>> "{foo} {} {bar} {}".format(1, 2, bar=4, foo=3)
'3 1 4 2'
#通过索引来指定要在哪个字段中使用相应的未命名参数
#花括号里面的数字是后面替换字段的索引
>>> "{foo} {1} {bar} {0}".format(1, 2, bar=4, foo=3)
'3 2 4 1'
#复杂例子：
>>> fullname = ["Alfred", "Smoketoomuch"]
>>> "Mr {name[1]}".format(name=fullname)
'Mr Smoketoomuch'
>>> import math
>>> tmpl = "The {mod.__name__} module defines the value {mod.pi} for π"
>>> tmpl.format(mod=math)
'The math module defines the value 3.141592653589793 for π'3.1.2 基本转换
指定要在字段中包含的值后，就可添加有关如何设置其格式的指令了。
>>> "The number is {num}".format(num=42)
'The number is 42'
>>> "The number is {num:f}".format(num=42)
'The number is 42.000000'
#冒号和感叹号都可以实现
>>> print("{pi!s} {pi!r} {pi!a}".format(pi="π"))
π 'π' '\u03c0'字符串格式设置中的类型说明符：
b 将整数表示为二进制数
c 将整数解读为Unicode码点
d 将整数视为十进制数进行处理，这是整数默认使用的说明符
e 使用科学表示法来表示小数（用 e 来表示指数）
E 与 e 相同，但使用 E 来表示指数
f 将小数表示为定点数
F 与 f 相同，但对于特殊值（ nan 和 inf ），使用大写表示
g 自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数
G 与 g 相同，但使用大写来表示指数和特殊值
n 与 g 相同，但插入随区域而异的数字分隔符
o 将整数表示为八进制数
s 保持字符串的格式不变，这是默认用于字符串的说明符
x 将整数表示为十六进制数并使用小写字母
X 与 x 相同，但使用大写字母
% 将数表示为百分比值（乘以100，按说明符 f 设置格式，再在后面加上%）
3.1.3 宽度、精度和千位分隔符
设置浮点数（或其他更具体的小数类型）的格式时，默认在小数点后面显示6位小数，并根
据需要设置字段的宽度，而不进行任何形式的填充。
#数和字符串的对齐方式不同
>>> "{num:10}".format(num=3)
' 3' #9个空格
>>> "{name:10}".format(name="Bob")
'Bob ' #7个空格
>>> pi = 3.1415926
>>> "Pi day is {pi:.2f}".format(pi=pi)
'Pi day is 3.14'
#同时指定宽度和精度
>>> "{pi:10.2f}".format(pi=pi)
' 3.14'
#可使用逗号来指出你要添加千位分隔符
#逗号应放在宽度和表示精度的句点之间
>>> 'One googol is {:,}'.format(10**100)
'One googol is 10,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000'3.1.4 符号、对齐和用 0 填充
在指定宽度和精度的数前面添加标志：零、加号、减号或空格，其中零表示使用0来填充数字。（+：正数加上+号，-：默认设置，无正号）
>>> '{:010.2f}'.format(pi)
'0000003.14'
>>> '{: 10.2f}'.format(pi)
' 3.14'
>>> '{:+10.2f}'.format(pi)
' +3.14'
>>> '{:-10.2f}'.format(pi)
' 3.14'指定左对齐、右对齐和居中，可分别使用 < 、 > 和 ^ 。使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。更具体的说明符 = ，它指定将填充字符放在符号和数字之间。
>>> 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:10.2f}\n{1:10.2f}'.format(pi, -pi))
3.14
-3.14
>>> print('{0:10.2f}\n{1:=10.2f}'.format(pi, -pi))
3.14
- 3.14#：略
3.2 字符串方法
3.2.1 center
方法 center 通过在两边添加n个 A 填充字符（默认为空格）让字符串居中。
例如：‘abcdef’.center(n,"A")
#填充符号使用单双引号均可
>>> "Hello World".center(15)
' Hello World '
>>> "Hello World".center(15,'-')
'--Hello World--'
>>> "Hello World".center(15,"+")
'++Hello World++'3.2.2 find
方法 find 在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回 -1 。
>>> sentence = "Hello world!"
>>> sentence.find("wo")
6
>>> 'Hello world！'.find('Hello')
0
#指定起点和终点，搜索范围包含起点，但不包含终点
>>> sentence.find("wo",0,10)
63.2.2 join
join 是字符串方法，其作用与 split 相反，用于合并序列的元素。所合并序列的元素必须都是字符串。
>>> seq = [1, 2, 3, 4, 5]
>>> sep = '+'
>>> sep.join(seq)
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
sep.join(seq)
TypeError: sequence item 0: expected str instance, int found
#所有元素都应该是字符串
>>> seq = ['1', '2', '3', '4', '5']
>>> sep.join(seq)
'1+2+3+4+5'3.2.6 split
split 是一个字符串方法，其作用与 join 相反，用于将字符串拆分为序列。
如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符
等）处进行拆分。
>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']3.2.4 lower，
方法 lower 返回字符串的小写版本。
>>> 'Trondheim Hammer Dance'.lower()
'trondheim hammer dance'3.2.5 replace
方法 replace 将指定子串都替换为另一个字符串，并返回替换后的结果。
>>> 'This is a test'.replace('is', 'eez')
'Theez eez a test'3.2.7 strip
方法 strip 将字符串开头和末尾的空白（但不包括中间的空白）删除，并返回删除后的结果。也可在一个字符串参数中指定要删除哪些字符。
>>> ' internal whitespace is kept '.strip()
'internal whitespace is kept'
#只能删除首尾的指定字符
>>> '*** SPAM * for * everyone!!! ***'.strip(' *!')
'SPAM * for * everyone'3.2.8 translate
方法 translate 与 replace 一样替换字符串的特定部分，但不同的是它只能进行单字符替换。这个方法的优势在于能够同时替换多个字符，因此效率比 replace 高。
使用 translate 前必须创建一个转换表。这个转换表指出了不同Unicode码点之间的转换关系。要创建转换表，可对字符串类型 str 调用方法 maketrans ，这个方法接受两个参数：两个长度相同的字符串，它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字符。
#转换表：转换规则
>>> table = str.maketrans('cs', 'kz') #c->k s->z
>>> 'this is an incredible test'.translate(table)
'thiz iz an inkredible tezt'
#指定删除所有字符' '
>>> table = str.maketrans('cs', 'kz', ' ')
>>> 'this is an incredible test'.translate(table)
'thizizaninkredibletezt'四、映射
可通过名称来访问其各个值的数据结构。这种数据结构称为映射（mapping）。字典是Python中唯一的内置映射类型，其中的值不按顺序排列，而是存储在键下。键可能是数、字符串或元组。
4.1 创建和使用字典
字典以类似于下面的方式表示：
phonebook = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
字典由键及其相应的值组成，这种键-值对称为项（item）。每个键与其值之间都用冒号（ : ）分隔，项之间用逗号分隔，而整个字典放在花括号内，在字典（以及其他映射类型）中，键必须是独一无二的。空字典（没有任何项）用两个花括号表示，类似于下面这样： {} 。
4.1.1函数 dict
可使用函数 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'}4.1.2
字典的基本行为在很多方面都类似于序列。
len(d) 返回字典 d 包含的项（键-值对）数。
d[k] 返回与键 k 相关联的值。
d[k] = v 将值 v 关联到键 k 。
del d[k] 删除键为 k 的项。
k in d 检查字典 d 是否包含键为 k 的项。
虽然字典和列表有多个相同之处，但也有一些重要的不同之处。
键的类型：字典中的键可以是整数，但并非必须是整数。字典中的键可以是任何不可变的类型，如浮点数（实数）、字符串或元组。
自动添加：即便是字典中原本没有的键，也可以给它赋值，这将在字典中创建一个新项。然而，如果不使用 append 或其他类似的方法，就不能给列表中没有的元素赋值。
成员资格：表达式 k in d （其中 d 是一个字典）查找的是键而不是值，而表达式 v in l （其中 l 是一个列表）查找的是值而不是索引。这看似不太一致，但你习惯后就会觉得相当自然。毕竟如果字典包含指定的键，检查相应的值就很容易。
>>> zi = {'ab':556,'kk':898,'ol':777}
>>> ab in zi #使用in查找键要输入完整，比如引号
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
ab in zi
NameError: name 'ab' is not defined
>>> 777 in zi #使用in查找只能查找键，不能查找值
False
>>> 'ab' in zi
True
>>> zi[ab]
Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
zi[ab]
NameError: name 'ab' is not defined
>>> zi["ab"] #键要输入完整，包括引号
556
>>> zi["mmn"] = 999 # 将值 999 关联到键 mmn
>>> zi
{'ab': 556, 'kk': 898, 'ol': 777, 'mmn': 999}
>>> len(zi) #返回字典包含的项（键-值对）数。
4
>>> del(zi['ab']) # 删除键为 ‘ab’ 的项。
>>> zi
{'kk': 898, 'ol': 777, 'mmn': 999}4.2 字典方法
4.2.1 clear
方法 clear 删除所有的字典项，返回None。
#将空字典赋给x来“清空”，对y无影响还是指向原字典
>>> x = {}
>>> y = x
>>> x['key'] = 'value'
>>> y
{'key': 'value'}
>>> x = {}
>>> y
{'key': 'value'}
#使用clear删除原字典的所有元素，y也同时清空
>>> x = {}
>>> y = x
>>> x['key'] = 'value'
>>> y
{'key': 'value'}
>>> x.clear()
>>> y
{}4.2.2. copy
方法 copy 返回一个新字典，其包含的键-值对与原来的字典相同（这个方法执行的是浅复制，
因为值本身是原件，而非副本）。
>>> x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> y = x.copy()
>>> y['username'] = 'mlh' #替换副本中的值时，原件不受影响
>>> y['machines'].remove('bar') #修改副本中的值，原件也将发生变化
>>> y
{'username': 'mlh', 'machines': ['foo', 'baz']}
>>> x
{'username': 'admin', 'machines': ['foo', 'baz']}
#为避免这种问题，可使用深复制，即同时复制值及其包含的所有值等
#模块copy中的函数deepcopy 。
>>> 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']}4.2.3. fromkeys
方法 fromkeys 创建一个新字典，其中包含指定的键，且每个键对应的值都是 None 。
4.2.4 get
方法 get 为访问字典项提供了宽松的环境。通常访问字典中没有的项，将引发错误，但是使用 get 来访问不存在的键时，没有引发异常，而是返回 None 。可指定“默认”值，这样将返回你指定的值而不是 None 。
>>> d = {}
>>> print(d['name']) #直接访问出错
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: 'name'
>>> print(d.get('name')) #使用get不会报错，返回None
None
>>> d.get('name', 'N/A') #指定默认值
'N/A'
>>> d['name'] = 'Eric' #字典包含指定键，可找到相应的值
>>> d.get('name')
'Eric'4.2.5. items
方法 items 返回一个包含所有字典项的列表，其中每个元素都为 (key, value) 的形式。字典项
在列表中的排列顺序不确定。
>>> d = {'title': 'this is a title', 'url': 'http://www.title.com', 'spam': 0}
>>> d.items()
dict_items([('title', 'this is a title'), ('url', 'http://www.title.com'), ('spam', 0)])返回值属于一种名为字典视图的特殊类型。字典视图可用于迭代，还可确定其长度以及对其执行成员资格检查。 （视图的一个优点是不复制，它们始终是底层字典的反映）
4.2.6. keys
方法 keys 返回一个字典视图，其中包含指定字典中的键。
4.2.8. popitem
方法 popitem 类似于 list.pop ，但 list.pop 弹出列表中的最后一个元素，而 popitem 随机地弹出一个字典项，因为字典项的顺序是不确定的，没有“最后一个元素”的概念。返回值为被弹出的item。
>>> d = {'title': 'this is a title', 'url': 'http://www.title.com', 'spam': 0}
>>> d.popitem()
('spam', 990)
>>> d
{'title': 'this is a title', 'url': 'http://www.title.com'}4.2.9. setdefault
方法 setdefault 有点像 get ，因为它也获取与指定键相关联的值，但除此之外， setdefault
还在字典不包含指定的键时，在字典中添加指定的键-值对。
>>> d = {}
>>> d.setdefault('name',none) #值为字符串一定要加引号
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
d.setdefault('name',none)
NameError: name 'none' is not defined
>>> d.setdefault('name','none')
'none'
>>> d
{'name': 'none'}
>>> d.setdefault('ad',999) #值为数不用加引号
999
>>> d['name'] = 'Ab'
>>> d.setdefault('name')
'Ab'
>>> d
{'name': 'Ab', 'ad': 999}4.2.10. update
方法 update 使用一个字典中的项来更新另一个字典。old.update(new)，Old被替换掉的字典，new要使用的新字典。
4.2.11. values
方法 values 返回一个由字典中的值组成的字典视图。不同于方法 keys ，方法 values 返回的视
图可能包含重复的值。
五、条件 循环 和其他语句
5.1 print和import
5.1.1 打印多个参数
打印参数使用逗号隔开，默认每个参数打印出来会用空格隔开，可以使用'+'连接两个str消除默认空格；可自定义分隔符和结束字符串。（数字可使用str(number)装换成字符串。）
#print参数用逗号隔开，多个参数一起打印时会默认用空格隔开
>>> name = 'ab'
>>> ad = 'adress'
>>> greeting = 'hello'
>>> print(greeting,'Mr.',name, "in", ad,) #在参数前加空格不会对print影响
hello Mr. ab in adress
>>> print(greeting,'Mr.',name,"in",ad,)
hello Mr. ab in adress
>>> print(greeting,'Mr.'+name,"in",ad,) #不要空格则可以用‘+’连接
hello Mr.ab in adress
#自定义分隔符（sep="_"），结束字符串（end=' '）：
name = 'ab'
ad = 'adress'
greeting = 'hello'
print(greeting,'Mr.'+name,"in",ad,sep="_",end=' ')
print("how are you?")
输出结果：hello_Mr.ab_in_adress how are you?5.1.2 使用import导入时重名
从模块导入时，通常使用
import somemodule
from somemodule import somefunction
from somemodule import somefunction, anotherfunction, yetanotherfunction
from somemodule import * （导入模块中的所有function时使用此语句）
重名时可用：
module1.open(...)
module2.open(...)
导入特定函数并给它指定别名的例子：
>>> from math import sqrt as kf
>>> kf(4)
2.0
#重名函数open：
from module1 import open as open1
from module2 import open as open25.2.1 序列解包
序列解包（或可迭代对象解包）：将一个序列（或任何可迭代对象）解包，并将得到的值存储到一系列变量中。左右两边目标个数应当相同，否则出错。（并行赋值：）
#同时（并行）给多个变量赋值：
>>> x, y, z = 1, 2, 3
>>> print(x, y, z)
1 2 3
#交换多个变量的值：
>>> x, y = y, x
>>> print(x, y, z)
2 1 3
>>> values = 1, 2, 3
>>> values
(1, 2, 3)
>>> x, y, z = values
>>> x
1使用 popitem删除一个字典的键值对，将返回的元组解包到两个变量中：
>>> d = {'name':'ab','age':19}
>>> key,val = d.popitem()
>>> key
'age'
>>> val
19可使用（*）运算符收集多余值：
>>> d = ['ab','mmn','op','we','kl']
>>> A,B,*rest = d
>>> A
'ab'
>>> B
'mmn'
>>> rest
['op', 'we', 'kl']
>>> a,*b,c = rest
>>> a
'op'
>>> b #带星号的变量最终包含的总是一个列表
['we']
>>> c
'kl'
>>> 5.2.2 链式赋值
x = y = somefunction() 等价于
y = somefunction()
x = y
5.2.3 增强赋值
>>> x = 2
>>> x += 1
>>> x *= 2
>>> x
6
增强赋值也可用于其他数据类型，（只要使用的双目运算符可用于这些数据类型）
5.4 条件和条件语句
5.4.1 bool值
用作布尔表达式（如用作 if 语句中的条件）时，下面的值都将被解释器视为假：
False None 0 "" () [] {}
5.4.2 if else语句
if （条件）:
<tab>条件为真时执行语句
else:
<tab>条件为假时执行语句
5.4.3 elif语句，elif是else if 缩写
num = int(input('Enter a number: '))
if num > 0:
print('The number is positive')
elif num < 0:
print('The number is negative')
else:
print('The number is zero')5.4.4 更复杂的条件
Python比较运算符：
表 达 式 描 述
x == y x 等于 y
x < y x 小于 y
x > y x 大于 y
x >= y x 大于或等于 y
x <= y x 小于或等于 y
x != y x 不等于 y
x is y x 和 y 是同一个对象
x is not y x 和 y 是不同的对象
x in y x 是容器（如序列） y 的成员
x not in y x 不是容器（如序列） y 的成员
5.4.5 is
不要将 is 用于数和字符串等不可变的基本值：
a = 'hhj',b = 'hhj',a is b
a = c = 'hhj',a is c
-----------------------------------
a = ['hhj'],b = ['hhj'],a is not b #只有a、b为列表时is判断为假
a = ['hhj'],b = ['hhj'],a == b
a = c = ['hhj'],a is c
-----------------------------------
a = (1,2,3),b = (1,2,3),a is b
a = c = (1,2,3),a is c
5.4.6 布尔运算符
and or not 例如：
if ((cash > price) or customer_has_good_credit) and not out_of_stock:
give_goods()
5.4.7 断言
如果知道必须满足特定条件，程序才能正确地运行，可在程序中添加 assert 语句充当检查点。还可在条件后面添加一个字符串，对断言做出说明。
>>> age = -1
>>> assert 0 < age < 100, 'The age must be realistic'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AssertionError: The age must be realistic
5.5 循环
5.5.1 while 循环
x = 1
while x <= 100:
print(x)
x += 15.5.2 for 循环
基本上， 可迭代对象是可使用 for 循环进行遍历的对象：（只要能够使用 for 循环，就不要使用 while 循环）
words = ['this', 'is', 'an', 'ex', 'parrot']
for word in words:
print(word)
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for number in numbers:
print(number)鉴于迭代（也就是遍历）特定范围内的数是一种常见的任务，Python提供了一个创建范围的内置函数。
>>> range(0, 10)
range(0, 10)
>>> list(range(0, 10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#打印1-100
for number in range(1,101):
print(number)5.5.3 迭代字典
for 循环的优点之一是，可在其中使用序列解包
#使用普通的 for 语句：
d = {'x': 1, 'y': 2, 'z': 3}
for key in d:
print(str(key)+':'+str(d[key]))
print('-----------------------------')
# for 循环的优点之一是，可在其中使用序列解包
# d.items 以元组的方式返回键-值对：
for key, value in d.items():
print(str(key)+':'+str(value))
#输出结果：
x:1
y:2
z:3
-----------------------------
x:1
y:2
z:35.5.4 迭代
5.5.4.1 并行迭代
并行迭代工具，内置函数 zip ，它将两个序列“缝合”起来，并返回一个由元组组成的序列。当序列的长度不同时，函数 zip 将在最短的序列用完后停止。
names = ['anne', 'beth', 'george', 'damon']
ages = [12, 45, 32, 102]
for i in range(len(names)):
print(names[i], 'is', ages[i], 'years old')
#组合两个序列，返回一个由元组组成的序列
>>> list(zip(names, ages))
[('anne', 12), ('beth', 45), ('george', 32), ('damon', 102)]5.5.4.2 迭代时获取索引
内置函数enumerate，能够迭代 索引-值 对，其中的索引是自动提供的
strings = ['xxx','mmm','opp','kll']
for n, str in enumerate(strings):
if 'xxx' in str:
strings[n] = '[substitute]'
for i in range(len(strings)):
print(strings[i])
5.5.4.3 反向迭代和排序后再迭代
reversed 和 sorted可用于任何序列或可迭代的对象，且不就地修改对象，而是返回反转和排序后的版本。 sorted 返回一个列表，而 reversed 返回一个可迭代对象。
>>> sorted([4, 3, 6, 8, 3])
[3, 3, 4, 6, 8]
>>> sorted('Hello, world!')
[' ', '!', ',', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> list(reversed('Hello, world!'))
['!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H']
>>> ''.join(reversed('Hello, world!'))
'!dlrow ,olleH'5.5.5 跳出循环
1. break，要结束（跳出）循环，可使用 break 。
2. continue，语句 continue 没有 break 用得多。它结束当前迭代，并跳到下一次迭代开头。
3.while True/break
5.5.6 循环中的 else 子句
循环中添加的 else 子句，仅在没有调用 break 时才执行
#99-0降序找到最大完全平方数
from math import sqrt
for n in range(99, 0,-1):
root = sqrt(n) #root的值为浮点数
print(root)
if root == int(root): #直到root出现整数时root平方则为最大完全平方数81
print(n)
break
else:
print("Didn't find it!") #如果没找到，即没有运行break，则运行此行pyqt
pyqt5+sqlite3操作：
import sqlite3
# 创建db文件、products表、连接：
conn = sqlite3.connect('test_db2.db')
cur = conn.cursor()
cur.execute('''CREATE TABLE IF NOT EXISTS products(name,id )''') # 不存在则添加
conn.commit() # 执行操作
# 插入数据：
u_id = 000
u_name = 'ad'
# cur.execute('''INSERT INTO products VALUES (?,?)''', (u_name, u_id))
cur.execute('''INSERT INTO products VALUES (:name,:id)''', dict(name=u_name, id=u_id))
conn.commit() # 执行操作
# 搜索所有数据
with conn:
cur.execute('''SELECT * FROM products''')
print(cur.fetchall())
# 删除指定项
with conn:
u_id = 999
cur.execute('''DELETE FROM products WHERE id =?''', (u_id,))
# # 从文件插入数据
# with open('data.xxx') as f:
# f.readline()
# for i in range(4):
# line = f.readline()
# u_id, u_name = line.split(',')
# with conn:
# cur.execute('''INSERT INTO products VALUES(:id,:name)''',dict(id = u_id,name = u_name))
with conn:
u_id = 786
u_name = 'u_name'
cur.execute('''UPDATE products SET id=:id WHERE name=:name''', dict(id=u_id, name=u_name))
conn.close()
with conn:
code
模块相当于在一段后加上conn.commit() 执行操作
在PyCharm里添加UI界面
import sys
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
import NAME #UI转py文件的文件名
# 实例化，传参
app = QApplication(sys.argv)
# 创建对象
mainWindow = QMainWindow()
# 创建ui，引用NAME文件中的Ui_Form类
ui = NAME.Ui_Form()
# 调用Ui_MainWindow类的setupUi，创建初始组件
ui.setupUi(mainWindow)
# 创建窗口
mainWindow.show()
# 进入程序的主循环，并通过exit函数确保主循环安全结束(该释放资源的一定要释放)
sys.exit(app.exec_())QT多线程使用
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
