字符串、列表、元组、字典、集合 差异及关联
字符串、列表、元组、字典、集合 差异及关联
可迭代对象： 字符串，列表，元组，字典，集合，固定集合
可变容器： 列表，字典(无序)，集合(无序)，
不可变容器： 元组，固定集合(无序)
序列：字符串，列表，元组
集合，固定集合不重复元素
字典不重复键
字面值表示方法：
字符串 列表 元组 字典
'' [] () {}
"" 单元素加, :分隔键值对
''' '''
""" """
构造(创建)函数：
字符串： str()
列表： list() list(可迭代对象iterable)
元组： tuple() tuple(iterable)
字典： dict() dict(iterable) dict(命名关键字传参)
集合： set() set(iterable)
固定集合：frozenset() frozenset(iterable)
例：
d = dict([('name', 'tarena'), ('age', 15)])
d = dict(name='tarena', age=15)
索引 index：
字符串： 字符串[整数表达式]
列表： 列表[整数表达式] 可索引赋值
元组：等同列表
字典： 字典[键]
添加/修改字典元素：字典[键] = 值对象
若字典中有该键则修改原先值
切片slice:
字符串：字符串[开始索引 ：结束索引 ：步长]
列表： 列表[start index : end index : 步长]
切片赋值：列表[切片] = 可迭代对象
元组切片同列表规则相同
注：步长可省略，当步长为负整数时，反向切片。
元组的切片返回一个元组
元组不能索引赋值和切片赋值
推导式：
列表： [表达式 for 变量 in 可迭代对象] 或 [表达式 for 变量 in 可迭代对象 if 真值表达式]
字典：{键表达式 : 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
集合：{ 表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注：字典，集合中的中括号代表内容可省略
列表推导式的嵌套:
语法:
[表达式1
for 变量1 in 可迭代对象1 if 真值表达式1
for 变量2 in 可迭代对象2 if 真值表达式2]
示例：
想生成
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
[x + y for x in 'ABC' for y in '123']
字典推导式的嵌套：
语法同列表推导式嵌套
方法(常用)：
字符串：
S.isdigit() 判断字符串中的字符是否全为数字
S.isalpha() 判断字符串是否全为英文字母
S.islower() 判断字符串所有字符是否全为小写英文字母
S.isupper() 判断字符串所有字符是否全为大写英文字母
S.isspace() 判断字符串是否全为空白字符
S.center(width[,fill]) 将原字符串居中，左右默认填充空格
S.ljust(width[,fill]) 将字符串左对齐
S.rjust(width[,fill]) 将字符串右对齐
S.count(sub[, start[,end]]) 获取一个字符串中子串的个数
S.find(sub[, start[,end]]) 获取字符串中子串sub的索引,失败返回-1
S.strip() 返回去掉左右空白字符的字符串
S.lstrip() 返回去掉左侧空白字符的字符串
S.rstrip() 返回去掉右侧空白字符的字符串
S.upper() 生成将英文转换为大写的字符串
S.lower() 生成将英文转换为小写的字符串
S.replace(old, new[, count])
将原字符串的old用new代替，生成一个新的字符串
S.startswith(prefix[, start[, end]]) 返回S是否是以prefix开头，如果以prefix开头返回True,否则返回False,
S.endswith(suffix[, start[, end]]) 返回S是否是以prefix开头，如果以prefix开头返回True,否则返回False
S.title() 生成每个英文单词的首字母大写字符串
S.isnumeric() 判断字符串是否全为数字字符
列表：
L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误
L.insert(index, obj) 将某个元素插放到列表中指定的位置
L.count(x) 返回列表中元素的个数
L.remove(x) 从列表中删除第一次出现在列表中的值
L.copy() 复制此列表（只复制一层，不会复制深层对象)
L.append(x) 向列表中追加单个元素
L.extend(list) 向列表追加另一个列表
L.clear() 清空列表,等同于 L[:] = []
L.sort(reverse=False) 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列
L.reverse() 列表的反转，用来改变原列表的先后顺序
L.pop([index]) 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系
元组：
T.count(value) 返回元素个数（同list.count)
T.index(value, [start, [stop]]) 返回某个元素在元组的索引位置（同list.index)
字典：
D.clear() 清空字典
D.pop(key) 移除键，同时返回此键所对应的值
D.copy() 返回字典D的副本,只复制一层(浅拷贝)
D.update(D2) 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default) 返回键key所对应的值,如果没有此键，则返回default
D.keys() 返回可迭代的 dict_keys 集合对象（即得到键的集合）
D.values() 返回可迭代的 dict_values 值对象
D.items() 返回可迭代的 dict_items 对象
集合：
S.add(e) 在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e) 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e) 从集合S中移除一个元素e;
S.clear() 清空集合内的所有元素
S.copy() 将集合进行一次浅拷贝
S.pop() 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
S.update(s2) 用 S与s2得到的全集更新变量S
S.difference(s2) 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合
S.difference_update(s2) 等同于 S = S ^ s2
S.intersection(s2) 等同于S & s2
S.intersection_update(s2) 等同于S = S & s2
S.isdisjoint(s2) 如果S与s2交集为空返回True,非空则返回False
S.issubset(s2) 如果S与s2交集为非空返回True,空则返回False
S.issuperset(...) 如果S为s2的子集返回True,否则返回False
S.symmetric_difference(s2) 返回对称补集,等同于 S ^ s2
S.symmetric_difference_update(s2) 用S 与 s2的对称补集更新 S
S.union(s2) 生成 S 与 s2的全集
函数：
字符串编码转换函数
ord(c) 返回一个字符的Unicode值
chr(i) 返回i这个值所对应的字符
整数传换为字符串函数:
hex(i) 将整数转换为 十六进制字符串
oct(i) 将整数转换为 八进制字符串
bin(i) 将整数转换为 二进制字符串
数值对象的构造(创建)函数
float(obj) 用字符串或数字转换为浮点数
int(x='0', base=10) 用数字或字符串转换为整数，如果不给出参数，则返回0
complex(r=0.0, i=0.0) 用数字创建一个复数(实部为r,虚部为i)
bool(x) 用x创建一个布尔值(True/False)
python3常用于序列的函数:
len(seq) 返回容器的元素个数
max(x) 返回序列(或键)的最大值元素
min(x) 返回序列(或键)的最小值元素
sum(x) 返回序列(或键)中所有元素的和(元素必须是数值类型)
any(x) 真值测试, 如果容器内其中一个值为True则返回True,否则返回False
all(x) 真值测试, 容器内所有元素的布尔值为True才返回True
reversed(seq) 返回反向顺序的迭代器对象
sorted(iterable, reverse=False) 返回已排序的列表
运算：
字符串的运算:
+ 加号运算符用于拼接字符串
+= 运算符用原字符串与右侧字符串拼接生成新的字符串
示例：
s = 'ABCD' + 'EFG'
s += '123'
print(s)
s2 = s + s #
print(s2)
* 生成重复的字符串
*= 生成重复的字符串并让原变量绑定生成后的字符串
示例：
s = "ABC" * 3 # s='ABCABCABC'
print(s)
s2 = 5 * '0' # s3 = '00000'
s = "123"
s *= 3 # s = '123123123'
列表的运算:
+ 用于拼接列表
x = [1,2,3]
y = [4,5,6,7]
z = x + y # z = [1, 2, 3, 4, 5, 6, 7]
+= 用原列表与右侧列表拼接，并用变量绑定新列表
x = [1,2,3]
x += [4,5,6] # x = [1,2,3,4,5,6]
* 生成重复的列表
x = [1,2] * 3 # x = [1,2,1,2,1,2]
y = 3 * [5,6] # y = [5,6,5,6,5,6]
*= 生成重复的列表，并给原变量赋值
x = [3,4]
x *= 2 # x = [3,4,3,4]
y = 3
y *= [7,8] # y = [7,8,7,8,7,8]
元组的所有运算同列表的运算方式一致
集合的运算:
交集， 并集，补集，子集，超集
运算符:
& | - ^ < <= > >= == !=
in / not in
& 生成两个集合的交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 & s2 # {2, 3}
| 生成两个集合的并集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 | s2 # {1, 2, 3, 4}
- 生成两个集合的补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} #生成属性s1但不属于s2的所有元素的集合
^ 生成两个集合的对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 ^ s2 # {1, 4}
> 判断一个集合是另一个集合的超集
< 判断一个集合是别一个集合的子集
{1, 2, 3} > {1, 2} # True
{2, 3, 1} > {3, 2} # True
{2, 3, 4} < {1, 2, 3, 4} # True
== / != 集合相同和不同
{1, 2, 3} == {3, 2, 1} # True
{1, 2, 3} != {2, 3, 4} # True
frozenset 与 set 的运算完全相同
比较运算符：
字符串的比较运算:
>
>=
<
<=
==
!=
格式:
x > y
比较规则：
1. 字符串x的第一个字母与字符串y的第一个字母比较,如果不相同，则直接得到比较结果，如果相同，则再取第二个字母进行比较，以此类推
2. 比较的依据是字符的UNICODE编码值
列表的比较运算:
运算符:
< <= > >= == !=
示例：
[1,2,3] < [1,2,4] # True
[1,3] > [1,2,4] # True
[5] < [5, 0] # True
["ABC", "123"] > ['abc', '456'] # False
[1, "two"] > ["two", 1] # TypeError
[1, 2] < [3.3, 4] # True
[1] < ['2'] # TypeError
in / not in 运算符
作用：
用于序列，字典，集合等容器中，用于判断某个值是否存在于容器中,如果存在返回True,否则返回False
not in 与 in 运算符的返回结果相反
格式:
对象 in 序列