小白学Python 基础数据类型

一、可变类型与不可变类型

（一）不可变类型

不可变类型是指该种类型的数据一旦初始化后，对应内存地址上的数据不能被修改。
具体表现有：
1、对于某一变量赋相同的值，该变量指向的内存地址不发生变化
2、对于某一变量赋不同的值，该变量指向的内存地址发生变化

>>> s1 = '1'
>>> print(id(s1))
2732215782000
>>> s1 = '1'
>>> print(id(s1))
2732215782000
>>> s2 = '2'
>>> print(id(s2))
2732219984560
>>> s2 = '3'
>>> print(id(s2))
2732216851056

对于不可变类型对象的所有方法，执行后不修改原对象的数据，因此要得到修改后的结果必须拿变量接收。

>>> s2 = '3'
>>> s2 + '4'
'34'
>>> s2
'3'
>>> s3 = s2 + '4'
>>> s3
'34'

同样，对于iterable的不可变类型，虽然支持索引，但是不支持修改。

>>> s3
'34'
>>> s3[1]
'4'
>>> s3[1] = 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

还有一点需要注意：值相等并不等同于指向相同的对象，这就涉及到==和is的区别了。前者仅仅判断值是否相等，而is关键字判断是否指向同一对象。

>>> s3 = '34'
>>> id(s3)
1506116170864
>>> s3 += '5'
>>> s3
'345'
>>> s3 = s3.rstrip('5')
>>> s3
'34'
>>> id(s3)
1506116241776

在这段代码片中，虽然s3经历过+=赋值（对于可变类型，“+=”底层机制是调用的__iadd__魔法方法，但是str为不可变类型，因此用+或+=拼接之后id发生变化。有关魔法方法的讨论以后涉及）以及rstrip方法，得到的字符串和原s3字符串的值相同，但是用id()函数查询地址时，却发现打印的地址并不相同。
在基础数据类型中，不可变类型有number（int、float、complex）、bool类型、字符串str、元组tuple。

（二）可变类型

可变类型是指该种类型的数据一旦初始化后，对应内存地址上的数据可以被局部修改。
具体表现有：
对某一变量无论赋相同的值还是不同的值，该变量指向的内存地址都会发生变化。

>>> l1 = [1, 2, 3, 4]
>>> id(l1)
1506116263880
>>> l1 = [1, 2, 3, 4]
>>> id(l1)
1506116287688
>>> l1 = [2, 3, 4, 5]
>>> id(l1)
1506116315336

对于可变类型对象的所有方法，执行后修改原对象的数据，因此要得到修改后的结果无须拿变量接收，原变量已经被修改。

>>> l1
[2, 3, 4, 5]
>>> l1.append(6)
>>> l1
[2, 3, 4, 5, 6]

并且，可变类型的数据支持局部赋值，区别于不可变类型不支持局部赋值。

>>> l1
[2, 3, 4, 5, 6]
>>> l1[0] = 1
>>> l1
[1, 3, 4, 5, 6]

在基础数据类型中，可变类型有列表list，集合set，字典dict。

二、基础数据类型及方法

（一）字符串（str）

1、方法汇总及示例

方法	功能描述
.format()	格式化输出字符串，字符串中用{}占位，()中传递可变参数
.join()	连接任意数量的字符串。调用其方法的字符串插入到每个给定字符串之间，传递参数为可迭代对象，结果将作为新字符串返回。示例：’.’.join([‘ab’，‘pq’，‘rs’])->‘ab.pq.rs’
.split()	返回字符串中的单词列表list，使用sep作为分隔符字符串。sep：用于拆分字符串的分隔符。None（默认值）意味着根据任何空格拆分，并从结果中丢弃空字符串。maxsplit：要执行的最大拆分数。-1（默认值）表示无限制。示例：‘1 2 3’.split(maxsplit=1)->[‘1’, ‘2 3’]
.splitlines()	返回字符串中的行列表，在行边界处断开。换行符不包括在结果列表中，除非给定keepends并为True。示例：‘12\n12’.splitlines(keepends=True)->[‘12\n’, ‘12’]、‘12\n12’.splitlines()->[‘12’, ‘12’]
.replace()	返回一个副本，其中所有出现的子字符串old替换为new。count：要替换的最大出现次数。-1（默认值）表示替换所有引用。如果给定了count，则只替换count个子字符串。示例：‘123123’.replace(‘1’, ‘3’, 1)->‘323123’
.strip()	返回删除前导和尾随空白的字符串副本。如果给出了字符，而不是None，改为删除字符串中的该字符。示例：‘123123’.strip(‘3’)->‘12312’
.lstrip()	返回删除前导空白的字符串副本。如果给出了字符，而不是None，改为删除字符串中的该字符。示例：‘123123’.lstrip(‘1’)->‘23123’
.rstrip()	返回删除尾随空白的字符串副本。如果给出了字符，而不是None，改为删除字符串中的该字符。示例：‘123123’.strip(‘3’)->‘12312’
.lower()	返回转换为小写的字符串的副本。示例：‘ABCdef’.lower()->‘abcdef’
.upper()	返回转换为大写的字符串的副本。示例：‘ABCdef’.upper()->‘ABCDEF’
.encode()	使用注册用于编码的编解码器对字符串进行编码。encoding：对字符串进行编码的编码。error：用于编码错误的错误处理方案。默认值为“strict”，这意味着编码错误会引发UnicodeEncodeError。其他可能的值包括“ignore”、“replace”和“xmlcharrefreplace”，以及注册的可用于解决UnicodeEncodeError的codecs.register_error的任何其他名称。
.decode()	使用注册用于编码的编解码器进行解码。编码默认为默认编码。error：用于编码错误的错误处理方案。默认值为“strict”，这意味着编码错误会引发UnicodeEncodeError。其他可能的值包括“ignore”、“replace”和“xmlcharrefreplace”，以及注册的可用于解决UnicodeEncodeError的codecs.register_error的任何其他名称。
.startswith()	返回bool值。如果待检测字符串以指定的前缀开头，则返回True，否则返回False。有了可选的开始，测试从那个位置开始。在可选结束时，停止在该位置。前缀也可以是要尝试的字符串元组。示例：‘ABCdef’.startswith((‘ABC’, ‘DEF’), 0, 5)->True
.endswith()	返回bool值。如果待检测字符串以指定的后缀结尾，则返回True，否则返回False。有了可选的开始，测试从那个位置开始。在可选结束时，停止在该位置。后缀也可以是要尝试的字符串元组。示例：‘ABCdef’.endswith((‘ABC’,‘def’), 1, 6)->True
.find()	返回待检测字符串中找到待查找字符串sub的最低索引，以便sub包含在待检测字符串中[start:end]。可选参数start和end被解释为切片表示法。失败时返回-1。示例：‘123123’.find(‘1’)->0
.index()	返回待检测字符串中找到待查找字符串sub的最低索引，以便sub包含在待检测字符串中[start:end]。可选参数start和end被解释为切片表示法。找不到子字符串时引发ValueError。示例：‘123123’.index(‘1’)->0
.count()	返回待检测字符串中子字符串sub的不重叠出现次数[start:end]。可选参数start和end被解释为切片表示法。示例：‘123123’.count(‘12’,0,5)->2
.isdigit()	返回bool值。如果字符串是数字字符串，则返回True；否则返回False。如果字符串中的所有字符都是数字，并且字符串中至少有一个字符，则字符串是数字字符串。具体结果：True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字；False: 汉字数字；Error: 无。示例：‘123123’.isdigit()->True
.isdecimal()	返回bool值。如果字符串是数字字符串，则返回True；否则返回False。具体结果：True: Unicode数字，全角数字（双字节）；False: 罗马数字，汉字数字；Error: byte数字（单字节）。
.isnumeric()	返回bool值。如果字符串是数字字符串，则返回True；否则返回False。具体结果：True: Unicode数字，全角数字（双字节），罗马数字，汉字数字；False: 无；Error: byte数字（单字节）。
.isalpha()	返回bool值。如果字符串是字母字符串，则返回True，否则返回False。如果字符串中的所有字符都是字母，并且字符串中至少有一个字符，则字符串是字母的。示例：‘ABCdef’.isalpha()->True
.zfill()	在左边用零填充数字字符串，以填充给定宽度的字段。如果指定的长度小于原字符串的长度则返回原字符串。示例：‘123’.zfill(6)->‘000123’
.ljust()	返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。填充使用指定的填充字符完成（默认为空格）。示例：‘123’.ljust(6,‘4’)->‘123444’、‘123’.ljust(6)->'123 ’
.partition()	使用给定的分隔符将字符串分成三部分。这将在字符串中搜索分隔符。如果找到了分隔符，则返回一个3元组，其中包含分隔符前的部分、分隔符本身以及分隔符后的部分。如果找不到分隔符，则返回包含原始字符串和两个空字符串的3元组。示例：‘0123’.partition(‘2’)->(‘01’, ‘2’, ‘3’)

2、切片

字符串切片语法：

string[start_index: end_index: step]

字符串的正向索引以0为起始并逐项递增，反向索引以-1为起始并逐项递减
请注意：

1. 若采取正向切片，start_index、end_index均已0为起始，并使start_index小于end_index，step取正；若采取反向切片，start_index、end_index均已-1为起始，并使start_index大于end_index，step取负。否则均将切片失败。示例：‘0123’[0:3:-1]->’’
2. step表示切片步长，正负号表示切片方向
3. 切片范围为左闭右开区间，即包括start_index，不包括end_index

3、“+”和“*”

对于字符串这一不可变类型，“+”和“+=”表示字符串拼接和字符串拼接且赋值。
“*”表示复制字符串，string * num表示将string复制num次

4、转义字符

转义字符是指在指定字符前加\，会改变原有的字符含义，使之具有一些特定功能的用法。

转义字符	功能描述
\(在行尾时)	续行符，其后不能有任何字符，包括空格、注释等
\\	输出反斜杠
\’	输出单引号
\"	输出双引号
\a	响铃
\b	退格
\e	转义
\n	换行
\v	纵向制表位
\t	横向制表位
\r	回车
\f	换页
\o	八进制数
\x	十六进制数

（二）列表（list）

1、数据类型简介

列表list是一种容器类型的数据结构。相对于C语言中的静态数组，Python中的list的灵活性大大提高。C语言的静态数组类型必须指明，并且一经初始化，数组长度即不支持改变。Python中的列表的item支持多种数据类型，并且支持动态扩容。
列表语法：

list1 = [item1, item2, item3]

列表中的item支持多种数据类型，可以是str、tuple、list等，所以列表支持多重嵌套构成多维列表。

2、方法、函数汇总及示例

方法	功能描述
.append()	在列表尾增加元素。示例：l1=[1,2,3] l1.append([4,5])->l1=[1,2,3,[4,5]]
.extend()	在列表尾增加元素，括号内是iterable对象，将该对象的每一个item依次添加到列表尾。示例：l1=[1,2,3] l1.extend([4,5])->l1=[1,2,3,4,5]
.pop()	移除指定索引的元素并将该元素作为返回值，如果不填写索引值，则默认移除列表最后一个元素。示例：l1=[1,2,3] n1=l1.pop(2)->l1=[1,2] n1=3
.sort()	对列表进行排序，排序顺序以reverse关键字参数指定。如果传递了参数func，则使用该参数的方法进行排序。默认升序排序，reverse=True进行降序排列。示例：l1=[1,3,2] l1.sort(reverse=True)->l1=[3,2,1]
.index()	返回待查找元素的索引，查找失败返回ValueError。请注意：列表没有find方法。示例：11=[1,2,3] o1=l1.index(1)->o1=0
.remove()	移除指定值的一个元素。如果列表中有多个相同的值，则只移除第一个匹配项。示例：l1=[1,2,3,1] l1.remove(1)->l1=[2,3,1]
.insert()	将元素插入指定索引的位置。示例：l1=[1,3,4] l1.insert(1,2)->l1=[1,2,3,4]
.count()	返回指定元素的个数。示例：l1=[1,2,3,1] o1=l1.count(1)->o1=2
.reverse()	将列表逆序。示例：l1=[1,2,3] l1.reverse()->l1=[3,2,1]
.copy()	建立一份原列表的副本（此处涉及到浅拷贝和深拷贝的问题）。l1=[1,2,3] l2=l1.copy()->l2=[1,2,3]
.clear()	清空列表。示例：l1=[1,2,3] l1.clear()->l1=[]

函数	功能描述
max	获取列表最大值。示例：l1=[1,2,3] n1=max(l1)->n1=3
min	获取列表最小值。示例：l1=[1,2,3] n1=min(l1)->n1=1
sum	获取列表所有元素的和。示例：l1=[1,2,3] n1=sum(l1)->n1=6
	注意需要同类型的元素，max，min，sum这些数值操作才有意义，面对不同类型的比较，会引发TypeError。对于字符串列表，是按照元素的首字符对应的ASCII编码值来比较大小的
enumrate	返回enumerate object，用来获取该列表中所有对应索引和该元素的元组。
sorted	返回该列表排序的临时副本。该列表原有的顺序不改变。示例：l1=[1,2,3,1] l2=sorted(l1)->l1=[1,2,3,1] l2=[1,1,2,3]
del	删除语句，删除指定元素。示例：l1=[1,2,3] del l1[0]->l1=[2,3]
len	获取列表长度。示例：l1=[1,2,3] n1=len(l1)->n1=3

3、切片与数值运算符

切片语法与字符串类似：

list1[start_index, end_index, step]

注意点与字符串类似。list和str都是可切片对象，对于所有可切片对象，切片操作的语法均类似，可切片对象包括str，list，tuple等。
对于list，+和+=分别表示拼接与拼接且赋值。因为list是可变数据类型，在执行+和+=运算符的时候，调用的是__add__和__iadd__魔法方法。
对于list1 * num，表示将list1复制num次，拼接成一个新列表并返回。
示例：[1,2,3]+[4,5,6]->[1,2,3,4,5,6]
[1,2,3]*3->[1,2,3,1,2,3,1,2,3]

4、拆包

列表支持拆包操作。
示例：a,b,c=[1,2,3]->a=1 b=2 c=3

（三）元组（tuple）

1、数据类型简介

元组与列表很类似，支持索引、切片，元素同样支持多种数据类型，可以完成元组的嵌套。但是元组属于不可变类型，即元组是不可修改的列表。

tuple1 = [item1, item2, item3]

请注意：
（1）元组的定义方式：

# 元组支持多种数据类型
tuple1 = ('1', 2, (3, 4), [5, 6], {7, 8}, {'index_1':9, 'index_2':10})
# 未加括号的序列都默认是元组
tuple2 = '1', 2, (3, 4), [5, 6], {7, 8}, {'index_1':9, 'index_2':10}
# 在定义仅有一个元素的元组时，须加,作为结束，否则会将()判为运算符
tuple3 = (1,)

（2）若元组的元素为可变类型，仍可通过索引找到该元素并对其修改

tuple1 = ('1', 2, (3, 4), [5, 6], {7, 8}, {'index_1':9, 'index_2':10})
tuple1[3][1] = '6'

执行上述操作，返回结果为：

tuple1 = ('1', 2, (3, 4), [5, '6'], {7, 8}, {'index_1':9, 'index_2':10})

2、方法汇总及示例

方法	功能描述
.index()	返回待查找元素的索引，查找失败返回ValueError。请注意：元组没有find方法。示例：t1=(1,2,3) n1=t1.index(1)->n1=0
.count()	返回指定元素的个数。示例：t1=(1,2,3,1) n1=t1.count(1)->n1=2

元组同样支持索引和切片

3、拆包

元组支持拆包操作。
示例：a,b,c=(1,2,3)->a=1 b=2 c=3
元组的拆包常常与enumerate函数配合使用，进行迭代操作，同时获取索引和对应元素。

l1 = ['1', 2, (3, 4), [5, 6], {7, 8}, {'index_1':9, 'index_2':10}]
for index_item, item in enumerate(l1):
	print(index_item, item)

输出结果：

0 1
1 2
2 (3, 4)
3 [5, 6]
4 {8, 7}
5 {'index_1': 9, 'index_2': 10}

（四）字典（dict）

1、数据类型简介

字典是键值对的集合（key-value)，键值对是非常直观并且容易理解的数据格式，这种数据格式在许多场景得以运用。例如：redis数据库就是key-value的数据组织形式，json数据格式也可以很方便的与key-value数据进行转换。另外pandas库支持的Dataframe结构化数据也可以由dict生成。
字典语法：

dict1 = {key1:value1, key2:value2}

请注意：

1. 同一个dict中，key必须保证唯一，否则仅保留最后一个key-value。示例：{1:1,1:2}->{1:2}。
2. key必须是不可变类型，否则抛出TypeError: unhashable type。示例：{[1,2]:1}->TypeError: unhashable type: ‘list’

拓展：hash数据结构
hash表常常用于提高查找效率。在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字和hash存储结构中的唯一一个存储地址相对应。因而在查找时，仅需根据该对应关系f即可找到给定值K的地址f(K)，hash结构有望将查找的时间复杂度降到常数阶。将该对应关系f称为hash函数，按照这个思想建立的表为hash表。

1. hash函数本质是一个值到其地址的映射，因此hash函数可以有多种方式，仅需使任何关键字由hash函数产生的hash地址落在允许范围内即可
2. 对于不同的关键字，可能会得到相同的hash地址，这一现象称为hash冲突。具有相同值的关键字对该hash函数来说称为同义词，此时就要采取某些方式解决hash冲突。
3. hash函数的构造方法可以为
   直接定址法：取关键字或关键字的某个线性函数值作为hash地址，即H(key)=key或H(key)=a*key+b；
   除留余数法：取关键字被某个不大于hash表表长的数p后所得余数作为hash地址，即H(key)=key MOD p，p≤len(hashtable)；
   随机数法：取关键字的随机函数值作为hash地址，即H(key)=random(key)，当关键字长度不等时用此法较为恰当
4. 衡量hash函数好坏的重要标准是看关键字对应的hash地址是否能够均匀散列到允许的范围上，考虑的因素有：计算hash函数所需时间、关键字长度、hash表大小、关键字的分布情况、记录的查找频率
5. 处理冲突的方法可以为：开放定址法、再哈希法、链地址法等

与str，list，tuple不同，dict是不支持索引的，因此dict也就没有index，find方法以及切片操作了。在底层dict是一种hash结构，因此dict在增删查改等数据操作上会表现出更加优异的性能。

2、操作汇总及示例

（1）创建并访问字典

# 创建空字典
dict1 = {}
# 访问字典通过对应的key
dict2 = {'1':1, '2':[3, 4], '3':(5, 6), '4':{7, 8}, '5':{'1': 9, '2': 10}}
print(dict2['5'])

返回结果

{'1': 9, '2': 10}

如果待访问的key不存在于该字典中，则抛出KeyError

（2）增加及修改数据

# 通过新增键值对的方式增加数据
dict2 = {'1':1, '2':[3, 4], '3':(5, 6), '4':{7, 8}, '5':{'1': 9, '2': 10}}
dict2['6'] = 11
dict2['3'] = [5, 6]

返回结果

{'1': 1,
 '2': [3, 4],
 '3': [5, 6],
 '4': {7, 8},
 '5': {'1': 9, '2': 10},
 '6': 11}

（3）删除字典中的元素

先介绍del语句，在后续方法汇总及示例中介绍删除字典数据的方法

dict2 = {'1':1, '2':[3, 4], '3':(5, 6), '4':{7, 8}, '5':{'1': 9, '2': 10}}
del dict2['5']

返回结果

{'1': 1, '2': [3, 4], '3': [5, 6], '4': {7, 8}}

（4）方法汇总及示例

方法	功能描述
.items()	返回字典中所有的键值对。示例：{‘1’:1,‘2’:2}.items()->dict_items([(‘1’, 1), (‘2’, 2)])
.keys()	返回字典中所有的键值。示例：{‘1’:1,‘2’:2}.keys()->dict_keys([‘1’, ‘2’])
.values()	返回字典中所有的值。示例：{‘1’:1,‘2’:2}.values()->dict_values([1, 2])
.copy()	建立一份原字典的拷贝（此处涉及到浅拷贝和深拷贝的问题）。
.clear()	清空字典
.fromkeys()	依据给定的可迭代对象创建新字典。seq指定字典的键值，value指定默认值。示例：d1=dict.fromkeys([1,2,3],10)->d1={1: 10, 2: 10, 3: 10}
.get()	返回字典中指定键的值，若键不在字典中，返回设置默认值。此方法可以避开KeyError异常。示例：n1={‘1’:1,‘2’:2}.get(‘1’,0)->n1=1
.setdefault()	返回字典中指定键的值，若键不在字典中，则添加该键并将其值设为默认值。示例：d1={‘1’:1,‘2’:2} n1=d1.setdefault(‘3’,3)->d1={‘1’:1,‘2’:2,‘3’:3} n1=3
.update()	将另一字典的键值对更新到原字典中。示例：d1={‘1’:1,‘2’:2} d1.update({‘3’:3})->d1={‘1’:1,‘2’:2,‘3’:3}
.pop()	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。示例：d1={‘1’:1,‘2’:2} n1=d1.pop(‘2’,0)->d1={‘1’:1} n1=2
__contains__()（原来的has_key()）	如果指定键在字典中，返回True，否则返回False。示例：d1={‘1’:1,‘2’:2} d1.__contains__(‘1’)->True
	判断元素是否存在于容器中可用in语句。__contains__的功能可用：key in d1.keys()或者key in d1来代替

函数	功能描述
len	返回字典中键值对个数。示例：d1={‘1’:1,‘2’:2} n1=len(d1)->n1=2

（五）集合（set）

1、数据类型简介

集合是一个无序且不重复的序列。无序就说明了集合不支持索引和切片。不重复表明可以利用set与其他数据类型的类型转换来达到序列元素去重的目的。
集合语法：

set1 = {item1, item2, item3}
set2 = {iterable}

集合的创建可以由{}或者set()函数。请注意：若要创建空集合，仅能使用set()函数，因为{}是创建一个空字典，而不是空集合。
并且，Python支持由可迭代对象创建集合，例如str，list，tuple，以及用户自建的实现__getitem__魔法方法的类实例化的对象等。若该可迭代对象包含重复元素，在创建集合的时候会自动去重。

s1 = set([1, 2, 3, 2, 1])
print(s1)

返回结果

{1, 2, 3}

对于集合的不重复特性，其很适合用来作为字典的key

s1 = set('123')
d1 = dict.fromkeys(s1, 0)
print(d1)

返回结果

{'2': 0, '1': 0, '3': 0}

2、方法汇总及示例

方法	功能描述
.add()	将元素添加到集合中，如果元素已存在，则不进行任何操作。示例：s1={1,2,3} s1.add(4)->s1={1,2,3,4}
.update()	将可迭代对象的元素添加到集合中。可迭代对象可以有多个，用逗号隔开。示例：s1={1,2,3,4} s1.update([5,‘6’],{7,‘8’})->s1={1, 2, 3, 4, 5, ‘6’, 7, ‘8’}
.remove()	删除指定值的元素。如果元素不存在，抛出KeyError。示例：s1={1,2,3} s1.remove(2)->s1={1,3}
.discard()	删除指定值的元素。如果元素不存在，不会抛出异常。s1={1,2,3} s1.discard(2)->s1={1,3}
.pop()	随即删除集合中的一个元素，并将其作为返回值。s1={1,2,3} n1=s1.pop()->s1={1,3} n1=2
.clear()	清空一个集合
.copy()	建立一份原集合的拷贝
.isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。示例：s1={1,2,3} s2={1,2,4} print(s1.isdisjoint(s2))->False

3、集合的运算

集合支持交（∩）、并（∪）、差（-）运算，对应的运算符为：交：&；并：|；差：-（对应逻辑代数中的与、或、非）

# 以下示例来源于菜鸟教程
# https://www.runoob.com/python3/python3-set.html

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

与集合的运算相对应有各个函数实现。因为函数名冗长，记忆难度较大，且功能均可由运算符实现，所以函数的使用相对较少。

方法	功能描述
.difference()	返回两个集合的差集。示例：s1={1,2,3} s2={1,2,4} s3=s1.difference(s2)->s3={3}
.difference_update()	差集且赋值。示例：s1={1,2,3} s2={1,2,4} s1.difference_update(s2)->s1={3}
.intersection()	交集
.intersection_update()	交集且赋值
.symmetric_difference()	返回两个集合中不重复的元素集合。
.symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

拓展数据类型

Python有一个collections模块，包含了defaultdict，UserDict，OrderedDict，ChainMap，Counter等灵活度更高的数据类型。这些等到讲解collections模块的时候继续介绍。

欢迎继续关注系列文章，希望能为Python学习带来帮助。