注：本文所有代码均经过Python 3.7实际运行检验，保证其严谨性。

集合类型定义

集合是多个元素的无序组合，与数学中集合的概念一致（即具备互异性和无序性）。所谓互异性，是指集合中的每一个元素都是独一无二的，集合中不存在两个相同的元素。跟字典中的键一样，集合中的元素须是不可变数据类型。

集合的建立

集合用大括号{}表示，元素间用逗号隔开。

建立集合类型用{}或set()。

建立空集合类型，必须使用set()。不能用{}。这是因为，用{}定义的是字典类型的空字典，而用set()才能定义集合类型的空集合。如下所示：

a = set()
b = {}
print("a的类型为", type(a))  # 集合类型。
print("b的类型为", type(b))  # 字典类型。

<<<
a的类型为 <class 'set'>
b的类型为 <class 'dict'>
<<<

可变数据类型和不可变数据类型

可变数据类型有：list，dict，set。

不可变数据类型有：int，float，string，tuple，range()。

值得注意的是，虽然字典的键和集合中的元素要求是不可变数据类型，但是字典和集合本身都是可变数据类型。

两种方法建立集合类型的例子如下：

A = {"python", 123, ("python", 123)} #使用{}建立集合
B = set("pypy123")     #使用set{}建立集合
print("A =", A)
print("B =", B)

<<<
A = {123, 'python', ('python', 123)}
B = {'3', '2', 'p', 'y', '1'}
<<<

集合的操作符及运算

集合有6个基本操作符和4个增强操作符。

集合有6个基本操作符如下：

集合的4个增强操作符如下：

交集判定

S1.isdisjoint(S2)：S1与S2的集合交集是否为空，True为空，否则False。

集合运算的例子如下：

A = {"p", "y", 123}
B = {"1", "2", "3", "p", "y"}
print("A - B =", A - B) #A-B返回包含在A中，但不包含在B中的元素构成的集合。
print("B - A =", B - A) #B-A返回包含在B中，但不包含在A中的元素构成的集合。
print("A & B =", A & B) #A&B是交集运算，返回同时包含在A和B中的元素构成的集合。
print("A | B =", A | B) #A|B是并集运算，返回包含在A和B中的所有元素构成的集合。
print("A ^ B =", A ^ B) #A^B是对称差运算，返回A和B中的所有非相同元素构成的集合。

<<<
A - B = {123}
B - A = {'2', '1', '3'}
A & B = {'p', 'y'}
A | B = {'3', '2', 'p', 'y', '1', 123}
A ^ B = {'3', '2', '1', 123}
<<<

集合的操作方法或函数

设S为一个集合。

增长集合

S.add(elem)——添加一个元素（必须是不可变数据）。

S.update(Set)——批量添加其它集合中的所有元素。

缩减集合

S.remove(elem)——从集合中移除元素elem。如果elem不存在于集合中则会引发 KeyError。

S.discard(elem)——如果元素elem存在于集合中则将其移除。如果elem不存在，并不会报错。

S.pop()——从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError。

S.clear()——从集合中移除所有元素。

下面是集合的增长和缩减的方法或函数的一些例子：

S = {'a', 'b', 'c'}
#集合添加元素。

S.add('d')  #集合S添加一个元素。

S
Out[54]: {'a', 'b', 'c', 'd'}

S1 = {'e', 'f'}

S.update(S1)  #批量添加集合S1中的所有元素到集合S中。

S
Out[57]: {'a', 'b', 'c', 'd', 'e', 'f'}

#集合缩减元素。
S.remove('f')  #.remove(elem)移除单个元素elem。

S.remove('g')  #.remove(elem)移除的元素elem不存在时会报错。
Traceback (most recent call last):

  File "<ipython-input-59-d161f40a2bc5>", line 1, in <module>
    S.remove('g')

KeyError: 'g'


S.discard('e')  #.discard(elem)移除单个元素，同.remove(elem)。

S.discard('g')  #.discard(elem)移除的元素elem不存在时，不会报错。与.remove(elem)不同。

S.pop()  #随机移除S集合中的任意一个元素。
Out[62]: 'a'

S.pop()
Out[63]: 'c'

S
Out[64]: {'b', 'd'}

S.clear()  #一次性清空集合S中的所有元素。

S
Out[66]: set()

集合大小：len函数。

S = {1, 2, 3, 4, 'a', 'b', 'c', 'd'}

len(S)
Out[2]: 8

To be continued.

1月5日

Python零基础入门学习08：字符串的格式化

注：本文所有代码均经过Python 3.7实际运行检验，保证其严谨性。

字符串类型的格式化

格式化是对字符串进行格式表达的方法
-字符串格式化使用.format()方法，用法如下：
<模板字符串>.format(<逗号分隔的参数>)

这里要用到的概念是“槽”。Python语言采用“槽”机制+format()来形成字符串的格式化。
“槽”用{}表示，只能放在字符串中。

print("{}：计算机{}的CPU占用率为{}%".format("2020-1-5", "C", 10))

<<<2020-1-5：计算机C的CPU占用率为10%

format()中对应的3个参数的顺序也是0，1，2。上述3个槽依次的默认顺序为0，1，2。因此输出如上。但是，实际上每个槽{}中是可以填写顺序index的，比如代码可以改写如下：

print("{1}：计算机{0}的CPU占用率为{2}%".format("2020-1-5", "C", 10))

<<<C：计算机2020-1-5的CPU占用率为10%

这时，槽的默认顺序被改写了，形成了上述实际输出。

槽{}的内部对格式化的配置方式为{<参数序号>: <格式控制标记>}。

<格式控制标记>有以下6种：

<填充>——用于填充的单个字符。

<对齐>——<是左对齐，>是右对齐，^是居中对齐。如果没有对齐符号，默认是左对齐。
<宽度>——槽设定的输出宽度。当宽度少于字符本身的长度时，以字符本身的长度为准。

<,>——数字的千位分隔符。

<.精度>——浮点数小数精度或字符串最大输出长度。

<类型>——类型分为int和float型两种。

整数类型：b（二进制型）, c（unicode编码型）, d（十进制型）, o（八进制型）, x（小写的十六进制型）, X（大写的十六进制型），
浮点数类型：e（小e的科学计数法类型）, E（大E的科学计数法类型）, f（普通的浮点数类型）, %（百分数浮点数类型）。

字符串格式化的代码实例

<格式控制标记>的前3种代码举例如下：

print("{0:=^20}".format("PYTHON"))
print("{0:*>20}".format("BIT"))
print("{:10}".format("BIT"))

<<<
=======PYTHON=======
*****************BIT
BIT         #字符串长度为10。
<<<

{0:=^{20}中，冒号“:”前面的“0”表示<参数序号>，“=”表示<填充>的字符串，“}”表示<对齐>中的居中对齐，“20”表示<宽度>输出为20。

<格式控制标记>的后3种代码举例如下：

print("{0:,.2f}".format(12345.6789))
print("{0:b}, {0:c}, {0:d}, {0:o}, {0:x}, {0:X}".format(425))

<<<
12,345.68
110101001, Ʃ, 425, 651, 1a9, 1A9
<<<

print("{0:e}, {0:E}, {0:f}, {0:%}".format(3.14))

<<<3.140000e+00, 3.140000E+00, 3.140000, 314.000000%

To be continued.