python 运算符 列表操作 元组

可以对字符串进行切片访问（同时适用于字符、列表、元组等）。
字符串从左往右，索引从0开始；从右往左，索引从–1开始。可以取字
符串中的片段，切片索引按左闭右开原则：
var = 'Hello World!'
# 按索引取部分内容，索引从0开始, 左必须小于右
# 支持字符、列表、元组
var[0] # 'H'
# 从右往左，索引从-1开始
var[-1] # '!'
var[-3:-1] # 'ld'
var[1:7] # 'ello W'（有个空格，不包含最后一位索引7）
var[6:] # 'World!' （只指定开头，包含后面所有的字符）
var[:] # 'Hello World!'（相当于复制）
var[0:5:2] # 'Hlo'（2为步长，按2的倍数取）
var[1:7:3] # 'ello W' -> 'eo'
var[::-1] # '!dlroW olleH'（实现反转字符功能）
下面是一些最常用的字符操作：
len('good') # 4 （字符的长度）
'good'.replace('g', 'G') # 'Good' （替换字符）
'山-水-风-雨'.split('-') # ['山', '水', '风', '雨'] （用指定字符分隔，默认空格）
'好山好水好风光'.split('好') # ['', '山', '水', '风光']
'-'.join(['山','水','风','雨']) # '山-水-风-雨'
'和'.join(['诗', '远方']) # '诗和远方'
'good'.upper() # 'GOOD' （全转大写）
'GOOD'.lower() # 'good' （全转小写）
'Good Bye'.swapcase() # 'gOOD bYE' （大小写互换）
'good'.capitalize() # 'Good' （首字母转大写）
'good'.islower() # True （是否全是小写）
'good'.isupper() # False （是否全是大写）
'3月'.zfill(3) # '03月' （指定长度，如长度不够，前面补0）

b / a # 2.1
a ** b # 表示10的21次幂
b % a # 1 （取余）
# 地板除，相除后只保留整数部分，即向下取整
# 但如果其中一个操作数为负数，则取负无穷大方向距离结果最近的整数
9//2 # 4
9.0//2.0 # 4.0
-11//3 # -4
-11.0//3 # -4.0

a = [1, 2, 3]
len(a) # 3（元素个数）
max(a) # 3（最大值）
min(a) # 1（最小值）
sum(a) # 6（求和）
a.index(2) # 1（指定元素位置）
a.count(1) # 1（求元素的个数）
for i in a: print(i) # 迭代元素
sorted(a) # 返回一个排序的列表，但不改变原列表
any(a) # True（是否至少有一个元素为真）
all(a) # True（是否所有元素为真）
a.append(4) # a: [1, 2, 3, 4]（增加一个元素）
a.pop() # 每执行一次，删除最后一个元素
a.extend([9,8]) # a: [1, 2, 3, 9, 8]（与其他列表合并）
a.insert(1, 'a') # a: [1, 'a', 2, 3]（在指定索引位插入元素，索引从0开始）
a.remove('a') # 删除第一个指定元素
a.clear() # []（清空）

需要熟练掌握列表的推导式，可以由可迭代对象快速生成一
个列表。推导式就是用for循环结合if表达式生成一个列表，这是一个非
常方便紧凑地定义列表的方式，可以大大减少代码量。
# 将一个可迭代的对象展开，形成一个列表
[i for i in range(5)]
# [0, 1, 2, 3, 4]
# 可以将结果进行处理
['第'+str(i) for i in range(5)]
# ['第0', '第1', '第2', '第3', '第4']
# 可以进行条件筛选，实现取偶数
[i for i in range(5) if i%2==0]
# 拆开字符，过滤空格，全变成大写
[i.upper() for i in 'Hello world' if i != ' ']
# ['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']

元组（tuple）跟列表（list）非常相似，二者之间的差异是元组不
可改变，而列表是可以改变的。元组使用圆括号()，列表使用方括号
[]。
元组的索引机制跟列表完全一样。元组是不可修改的，我们修改元
素时，就会报错，但是我们可以修改混杂类型里的列表类型数据。
另外，我们需要掌握元组的解包操作，这些操作可以让我们灵活地
赋值、定义函数、传参，非常方便。
x = (1,2,3,4,5)
a, *b = x # a占第一个，剩余的组成列表全给b
# a -> 1
# b -> [2, 3, 4, 5]
# a, b -> (1, [2, 3, 4, 5])
a, *b, c = x # a占第一个，c占最后一个，剩余的组成列表全给b
# a -> 1
# b -> [2, 3, 4]
# c -> 5
# a, b, c -> (1, [2, 3, 4], 5)

字典是Python重要的数据结构，由键值对组成。在客观世界中，所
有的事件都有它的属性和属性对应的值，比如某种花的颜色是红色，有
5个花瓣。其中颜色和花瓣数量是属性，红色和5是值。我们用属性
（key）和值（value）组成“键值对”（key-value）这样的数据结构。它
可以用以下方法定义：
d = {} # 定义空字典
d = dict() # 定义空字典
d = {'a': 1, 'b': 2, 'c': 3}
d = {'a': 1, 'a': 1, 'a': 1} # {'a': 1} key不能重复，重复时取最后一个
d = {'a': 1, 'b': {'x': 3}} # 嵌套字典
d = {'a': [1,2,3], 'b': [4,5,6]} # 嵌套列表
# 以下均可定义如下结果
# {'name': 'Tom', 'age': 18, 'height': 180}
d = dict(name='Tom', age=18, height=180)
d = dict([('name', 'Tom'), ('age', 18), ('height', 180)])
d = dict(zip(['name', 'age', 'height'], ['Tom', 18, 180]))
访问字典的方法如下：
d['name'] # 'Tom'（获取键的值）
d['age'] = 20 # 将age的值更新为20
d['Female'] = 'man' # 增加属性
d.get('height', 180) # 180
# 嵌套取值
d = {'a': {'name': 'Tom', 'age':18}, 'b': [4,5,6]}
d['b'][1] # 5
d['a']['age'] # 18
常用的字典操作方法如下：
d.pop('name') # 'Tom'（删除指定key）
d.popitem() # 随机删除某一项
del d['name'] # 删除键值对
d.clear() # 清空字典
# 按类型访问，可迭代
d.keys() # 列出所有键
d.values() # 列出所有值
d.items() # 列出所有键值对元组（k, v）
# 操作
d.setdefault('a', 3) # 插入一个键并给定默认值3，如不指定，则为None
d1.update(dict2) # 将字典dict2的键值对添加到字典dict
# 如果键存在，则返回其对应值；如果键不在字典中，则返回默认值
d.get('math', 100) # 100
d2 = d.copy() # 深拷贝，d变化不影响d2
d = {'a': 1, 'b': 2, 'c': 3}
max(d) # 'c'（最大的键）
min(d) # 'a'（最小的键）
len(d) # 3（字典的长度）
str(d) # "{'a': 1, 'b': 2, 'c': 3}"（字符串形式）
any(d) # True（只要一个键为True）
all(d) # True（所有键都为True）
sorted(d) # ['a', 'b', 'c']（所有键的列表排序）
2.2.7 集合
集合（set）是存放无顺序、无索引内容的容器。在Python中，集合
用花括号{}表示。我们用集合可以消除重复的元素，也可以用它作交、
差、并、补等数学运算。以下是它的定义方法：
s = {} # 空集合
s = {'5元', '10元', '20元'} # 定义集合
s = set() # 空集合
s = set([1,2,3,4,5]) # {1, 2, 3, 4, 5}（使用列表定义）
s = {1, True, 'a'}
s = {1, 1, 1} # {1}（去重）
type(s) # set（类型检测）
集合没有顺序，没有索引，所以无法指定位置去访问，但可以用for
遍历的方式进行读取。以下是一些常用的操作：
s = {'a', 'b', 'c'}
# 判断是否有某个元素
'a' in s # True
# 添加元素
s.add(2) # {2, 'a', 'b', 'c'}
s.update([1,3,4]) # {1, 2, 3, 4, 'a', 'b', 'c'}
# 删除和清空元素
s.remove('a') # {'b', 'c'}（删除不存在的会报错）
s.discard('3') # 删除一个元素，无则忽略，不报错
s.clear() # set()（清空）
集合的数学运算如下：
s1 = {1,2,3}
s2 = {2,3,4}
s1 & s2 # {2, 3}（交集）
s1.intersection(s2) # {2, 3}（交集）
s1.intersection_update(s2) # {2, 3}（交集，会覆盖s1）
s1 | s2 # {1, 2, 3, 4}（并集）
s1.union(s2) # {1, 2, 3, 4}（并集）
s1.difference(s2) # {1}（差集）
s1.difference_update(s2) # {1}（差集，会覆盖s1）
s1.symmetric_difference(s2) # {1, 4}（交集之外）
s1.isdisjoint(s2) # False（是否没有交集）
s1.issubset(s2) # False （s1是否是s2的子集）
s1.issuperset(s2) # False（s1是否是s2的超集，即s1是否包含s2中的所有元素