1. 元组简介
元组基本介绍：
1) 元组表现形式是 tuple。
2) Python的 元组 与 列表 类似，不同之处在于元组的元素不能修改。所以 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
1.1 元组的 增
3) 元组使用小括号既 () 创建元素。
# 创建一个 空元组
tuple = ()
4) 元组创建很简单，只需要在括号中添加元素，元素之间使用逗号隔开即可；当元组不是空元组时括号可以省略。
>>>tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>
5) 元组中 只包含一个元素 时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
>>>tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
1.2 元组的 改
6) 修改元组：元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
# (12, 34.56, 'abc', 'xyz')
1.3 元组的 删
7) 删除元组：元组中的元素值是不允许删除的，但我们可以使用 del语句 来删除整个元组。
tup = ('Google', 'CSDN', 1997, 2000)
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
# 删除后的元组 tup :
# Traceback (most recent call last):
# File "test.py", line 8, in <module>
# print (tup)
# NameError: name 'tup' is not defined
1.4 元组的 查
8) 访问元组：元组可以使用下标索引来访问元组中的值。
tup1 = ('Google', 'CSDN', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
# tup1[0]: Google
print ("tup2[1:5]: ", tup2[1:5])
# tup2[1:5]: (2, 3, 4, 5)
9) 元组解包 指将元组当中的每一个元素都赋值给一个变量。
my_tuple = 10,20,30,40 # 当元组不为空时，括号是可以省略的
a,b,c,d = my_tuple # 元组的解包 解包就是指将元组当中的每一个元素都赋值给变量
print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d)
# a = 10
# b = 20
# c = 30
# d = 40
# 在元组解包时，变量的数量必须和元组中的数据一一对应；
# 如果出现的变量和元组中元素数量不一致时，在收纳多余元素的变量前加 * ；
# 变量数量不可多于元组中的元素数量
# a,b = my_tuple # 值太多了，变量不够。 # ValueError: too many values to unpack (expected 2)
a,b,*c = my_tuple # * ：以 列表 的形式，把剩余的元素打包赋值给 c
print('a =',a)
print('b =',b)
print('*c =',*c)
# a = 10
# b = 20
# *c = 30 40
# a,b,*c = [1,2,3,4,5,6,7,8,9]
a,b,*c = 'python and JAVA'
print('a =',a)
print('b =',b)
print('*c =',*c)
print('c =',c)
# a = p
# b = y
# *c = t h o n a n d J A V A
# c = ['t', 'h', 'o', 'n', ' ', 'a', 'n', 'd', ' ', 'J', 'A', 'V', 'A']
print(my_tuple,type(my_tuple))
# (10, 20, 30, 40) <class 'tuple'>
print(my_tuple[3])
# 40
10) 元组索引，截取：因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以 截取索引中的一段元素。
# 创建一个元组
L = ('Google', 'Taobao', 'Runoob')
运行实例如下：
>>> L = ('Google', 'Taobao', 'Runoob')
>>> L[2]
'Runoob'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'Runoob')
1.5 元组的 运算符 和 操作函数
11) 元组运算符：与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以 组合和复制，运算后会生成一个 新的元组。
12) 元组内置函数：Python元组包含了以下内置函数
最后 简单的解释一下为什么“元组是不可变的”：所谓 元组的不可变 指的是元组所指向的内存中的内容不可变。
>>> tup = ('C', 'S', 'D', 'N')
>>> tup[0] = 'g' # 不支持修改元素
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup) # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800 # 内存地址不一样了
从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。
2. 可变对象
Python中 数值类型（int和float）、字符串str、元组tuple 都是 不可变类型 ；而 列表list、字典dict、集合set 是 可变类型 。
可变对象中都保存了三个数据：
id(标识) type(类型) value(值)
在这里，我们说的可变变量指的是我们可以对对象里面的 value 进行改变。
2.1 第一个可变对象方法：修改列表
a = [1,2,3]
a[0] = 10 # (改对象)
print(a)
# [10, 2, 3]
这个操作是通过变量去修改对象的值；
这种操作不会改变变量所指向的对象。
a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112
a = [1,2,3]
print('修改后：',a,id(a))
# 修改前： [1, 2, 3] 2048896731392
这个操作在给变量 重复赋值；
这种操作会改变变量所指向的存储对象。
如果不太理解上面这段话想传递给你的意思，我给你一个能让你快速理解上面这段话的方法和思想实验：多创建几个 相同的变量 a ，创建好后 打印它们的id 看输出的值后 你应该能理解。这个反馈的id的值就是这个 变量 a 在我们使用的硬盘里的位置 。你有十几个或几百个和你的 长相长得 一模一样的“兄弟” 或者是 和你的 名字 一模一样人，虽然他们都和你 住在同一个地球上，但你们 不可能会 住在同一个国家、同一个城市、同一个小区、同一个房间。
2.2 第二个可变对象方法：修改索引
a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112
# 通过索引修改列表
a[0] = 30
print('修改后：',a,id(a))
# 修改后： [30, 2, 3] 2020252459904
2.3 第三个可变对象方法：修改变量
a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112
# 通过变量给列表重新赋值
a = [7,8,9]
print('修改后：',a,id(a))
# 修改后： [7, 8, 9] 2681969838464
2.4 接下来我们讲第三个可变对象方法：修改对象
修改对象里的值会影响到所有指向该对象的 变量值，但不会改变该对象的 id。
a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112
# 修改对象里的值会影响到所有指向该对象的变量值，但不会改变该对象的 id
b = a
b[0] = 30
print('修改后：',b,id(b))
# 修改后： [30, 2, 3] 2048896738112
修改对象的列表 不仅会影响到所有指向该对象的 变量值，还会改变该对象的 id。
a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112
# 修改对象里的列表 不仅会影响到所有指向该对象的变量值，还会改变该对象的 id
b = a
b = [50,60,90]
print('修改后：',b,id(b))
# 修改后： [50, 60, 90] 2823356090688
3. 字典简介
3.1 字典的基本介绍
“字典”，我第一次听到这个词的时候给我的第一感觉还是怪瘆人的。 为什么？ 原因很简单：因为，学习了计算机这么久，但是以前都没听过。现在我就给大家简单且通俗易懂的解释一下 什么是Python语言里的“字典”。
Python语言 里有种一种可变容器模型，且可存储任意类型对象；它的特点是 能对数据快速进行检索。我们对这类 数据存储方式 ，叫“ 键(key)·值(value)对(key-value) ”，它的整体布局和使用就像我们小时候使用的 《新华字典》 是一样一样的；所以，我们简称这种数据存储格式为 “字典”；通过 “键(key)” 来索引查找相对的“值(value)”。字典的 值(value) 可以是 任意对象，你没有看错；但字典的键(key) 可以是 任意的不可变对象 ；简单的讲，不同版本的 《新华字典》 内容还是大同小异的，但页数是基本不变的(加量不加价的…)；内容是可以随着版本不断的更新而改变的，但那一页对应的是什么内容是不可更改的。字典的 键(key) 是不能重复的，就像一本字典里不可能出现内容不同却页数相同的两页(逻辑不附)；如果出现重复的键(key)，后面的键(key)·值(value)对(key-value) 会替换 前面的键(key)·值(value)对(key-value)。
OK，废话了这么多，接下来我来详细且专业的给大家介绍一下字典的各项属性、特点和使用。
字典是另一种可变容器模型，且可存储 任意类型对象。
字典属于一种新的数据结构称为 映射(mapping)；
字典的作用和列表类似，都是用来存储对象的容器；
列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反；
在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素；
这个 唯一的名字 我们称之为 键(key) 通过key可以快速查询到对应的 value 也可以称之为 值；
字典我们也称之为 键(key)·值(value)对(key-value) 结构
每个字典中都 可以有多个 键值对(key-value)，而每一个 键值对(key-value) 我们称其为 一项(item)；
字典的每个 键(key)与值(value) 之间用 冒号( : ) 分割 ，每个对之间用逗号(,)分割，整个字典 包括在 花括号({}) 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
字典的 值(value) 可以是 任意对象，字典的 键(key) 可以是 任意的不可变对象(int str bool tuple…)；
字典的 键(key) 是 不能重复 的，如果出现重复的后面的键(key)·值(value)对会替换前面的键(key)·值(value)对。
一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
3.2 字典的使用
我们根据 增·删·改·查 思路来拆解字典的使用
3.2.1 字典的 查 – 遍历字典
我们主要可以通过下面 4种方式 对字典进行遍历。
keys() ：该方法返回字典所有的key；返回一个迭代器，可以使用 list() 来转换为列表。
>>> dict = {'Name': 'Jiang', 'Age': 27}
>>> dict.keys()
dict_keys(['Name', 'Age'])
>>> list(dict.keys()) # 转换为列表
['Name', 'Age']
>>>
values() ：该方法返回 一个序列 ，序列中保存有 字典所有的值；返回一个迭代器，可以使用 list() 来转换为列表。
dict = {'Name': 'Jiang', 'Age': 27, 'Class': 'Read'}
print("字典所有值为 : ", list(dict.values()))
# 字典所有值为 : ['Jiang', 27, 'Read']
items() ：该方法会返回字典中 所有的项，它返回一个 序列，序列中包含有 双值子序列，双值分别是字典中的 键(key)与值(value) 。
dict = {'Name': 'Jiang', 'Age': 27}
print("Value : %s" % dict.items())
# Value : dict_items([('Name', 'Jiang'), ('Age', 27)])
访问字典里的值；把相应的键放入到方括号中就可以了；如下实例：
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
# 输出结果：
# dict['Name']: Runoob
# dict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("dict['Alice']: ", dict['Alice'])
# 输出结果：
# Traceback (most recent call last):
# File "test.py", line 5, in <module>
# print ("dict['Alice']: ", dict['Alice'])
# KeyError: 'Alice'
3.2.2 字典的 增 和 改
向字典 添加 新内容的方法是 增加新的键/值对，修改 已有键/值对 如下实例：
dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}
print("没修改的 dict: ", dict)
# 没修改的 dict: {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}
print("没修改的 dict['Age']: ", dict['Age'])
# 没修改的 dict['Age']: 7
dict['Age'] = 8 # 更新 Age
dict['Blog'] = "云山·若水的博客" # 添加信息
print("修改后的 dict: ", dict)
# 修改后的 dict: {'Name': 'CSDN', 'Age': 8, 'Class': 'Read', 'Blog': '云山·若水的博客'}
print("修改后的 dict['Age']: ", dict['Age'])
# 修改后的 dict['Age']: 8
print("修改后的 dict['Blog']: ", dict['Blog'])
# 修改后的 dict['Blog']: 云山·若水的博客
3.2.3 字典的 删
删除字典元素 能删单一的元素也 能清空字典，清空只需一项操作。显示删除一个字典用 del 命令，如下实例：
dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}
print("没修改的 dict[]: ", dict)
# 还没修改的 dict[]: {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}
del dict['Name'] # 删除键 'Name'
print("修改后的 dict[]: ", dict)
# 修改的后的 dict[]: {'Age': 7, 'Class': 'Read'}
dict.clear() # 清空字典
del dict # 删除字典
print ("修改后的 dict['Age']: ", dict['Age'])
print ("修改后的 dict['School']: ", dict['School'])
# Traceback (most recent call last):
# File "test.py", line 9, in <module>
# print ("dict['Age']: ", dict['Age'])
# TypeError: 'type' object is not subscriptable
3.2.4 字典键的特性
字典值可以是任何的 Python 对象，既可以是标准的对象，也可以是用户自定义的，但键不行。
而且，下面的 两个重要的点 需要记住：
1) 不允许 同一个键出现两次。这个注意点在开篇时就着重的多次提到过。创建时如果出现重复的键(key)，后面的键(key)·值(value)对(key-value) 会替换 前面的键(key)·值(value)对(key-value)。如下实例：
dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read', 'Name': '小菜鸟'}
print ("dict['Name']: ", dict['Name'])
# dict['Name']: 小菜鸟
2) 键必须不可变！！！所以可以用 数字、字符串 或 元组 充当，但用列表就不行。如下实例：
dict = {['Name']: 'CSDN', 'Age': 7, 'Class': 'Read'}
print ("dict['Name']: ", dict['Name'])
# 输出结果：
# Traceback (most recent call last):
# File "test.py", line 3, in <module>
# dict = {['Name']: 'Runoob', 'Age': 7}
# TypeError: unhashable type: 'list'
3.2.5 字典的内置函数&方法
Python字典包含了以下内置函数：
Python字典包含了以下内置方法：
1) radiansdict.clear() ：删除字典 内所有元素
dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}
print ("字典长度 : %d" %len(dict))
# 字典长度 : 3
dict.clear()
print ("字典删除后长度 : %d" %len(dict))
# 字典删除后长度 : 0
2) radiansdict.copy() ：返回一个字典的 浅复制
dict1 = {'user': 'Jiang', 'num': [1, 2, 3]}
dict2 = dict1 # 浅拷贝: 引用对象
dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
# 修改 data 数据
dict1['user'] = 'root'
dict1['num'].remove(1)
# 输出结果
print(dict1,id(dict1))
# {'user': 'root', 'num': [2, 3]} 2071738592064
print(dict2,id(dict2))
# {'user': 'root', 'num': [2, 3]} 2071738592064
print(dict3,id(dict3))
# {'user': 'Jiang', 'num': [2, 3]} 2071738592128
3) radiansdict.fromkeys(seq[, value])：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %str(dict))
# 新的字典为 : {'age': None,'name': None,'sex': None}
dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %str(dict))
# 新的字典为 : {'age': 10, 'name': 10, 'sex': 10}
4) radiansdict.get(key, default=None) ：返回指定键的值，如果值不在字典中返回default(默认)值
dict = {'Name': 'Jiang', 'Age': 27}
print ("Age 值为 : %s" %dict.get('Age'))
# Age 值为 : 27
print ("Sex 值为 : %s" %dict.get('Sex', "NA"))
# Sex 值为 : NA
5) key in dict ：如果键在字典dict里返回true，否则返回false
dict = {'Name': 'Jiang', 'Age': 27}
# 检测键 Age 是否存在
if 'Age' in dict:
print("键 Age 存在")
else:
print("键 Age 不存在")
# 键 Age 存在
# 检测键 Sex 是否存在
if 'Sex' in dict:
print("键 Sex 存在")
else:
print("键 Sex 不存在")
# 键 Sex 不存在
# not in
# 检测键 Age 是否存在
if 'Age' not in dict:
print("键 Age 不存在")
else:
print("键 Age 存在")
# 键 Age 存在
6) radiansdict.items() ：以 列表返回 可遍历的(键, 值) 元组数组
dict = {'Name': 'Jiang', 'Age': 27}
print("Value : %s" % dict.items())
# Value : dict_items([('Name', 'Jiang'), ('Age', 27)])
7) radiansdict.keys() ：返回一个迭代器，可以使用 list() 来转换为列表
>>> dict = {'Name': 'Jiang', 'Age': 27}
>>> dict.keys()
dict_keys(['Name', 'Age'])
>>> list(dict.keys()) # 转换为列表
['Name', 'Age']
>>>
8) radiansdict.setdefault(key, default=None) ：和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict = {'Name': 'Jiang', 'Age': 27}
print("Age 键的值为 : %s" % dict.setdefault('Age', None))
# Age 键的值为 : 27
print("Sex 键的值为 : %s" % dict.setdefault('Sex', None))
# Sex 键的值为 : None
print("新字典为：", dict)
# 新字典为： {'Name': 'Jiang', 'Age': 27, 'Sex': None}
9) radiansdict.update(dict2) ：把 字典dict2 的 键/值对 更新到 dict 里。
dict = {'Name': 'Jiang', 'Age': 27}
dict2 = {'Class': 'Read'}
dict.update(dict2)
print("更新字典 dict : ", dict)
# 更新字典 dict : {'Name': 'Jiang', 'Age': 27, 'Class': 'Read'}
10) radiansdict.values() ：返回一个迭代器，可以使用 list() 来转换为列表
dict = {'Name': 'Jiang', 'Age': 27, 'Class': 'Read'}
print("字典所有值为 : ", list(dict.values()))
# 字典所有值为 : ['Jiang', 27, 'Read']
11) pop(key[,default]) ：删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回 default值。
site= {'name': 'CSDN', 'alexa': 10000, 'url': 'https://www.csdn.net'}
pop_obj=site.pop('name')
print(pop_obj)
# CSDN
12) popitem() ：删除并返回字典中的最后一对键(key) 和 值(value。
site= {'name': 'CSDN', 'alexa': 10000, 'url': 'https://www.csdn.net'}
pop_obj=site.popitem()
print(pop_obj)
# ('url', 'https://www.csdn.net')
print(site)
# {'name': 'CSDN', 'alexa': 10000}
4. 集合
4.1 集合简介
集合表现形式：set 集合；和 列表 非常相似。
不同点：
1) 集合 只能存储 不可变对象；
2) 集合中存储的对象是 无序 的；
3) 集合 不能出现 重复元素。
使用大括号 { } 来创建集合；
可以通过 set() 函数创建集合，或者将序列和字典 转换成 集合。
注意：创建一个 空集合 必须用 set() ，而不是 { }。因为 { } 是用来创建一个 空字典 的。
parame = {value01,value02,...}
# 或者
set(value)
参考实例：
>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
>>> # 下面展示两个集合间的运算.
...
>>> 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'}
类似列表推导式，同样集合支持集合推导式(Set comprehension):
>>>a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
4.2 集合的基本操作
我们根据 增·删·改·查 思路来拆解字典的使用
4.2.1 集合的查
使用 len() 来获取集合中元素的数量。语法格式如下：
len(s)
计算集合 s 元素个数。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
print(len(thisset))
# 4
判断元素 是否在集合中 存在。语法格式如下：
x in s
判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
print("Runoob" in thisset)
# False
print("Facebook" in thisset)
# True
print("Runoob" not in thisset)
# True
print("Facebook" not in thisset)
# False
4.2.2 集合的增 · 向集合里添加元素
add() 向集合中 添加元素。语法格式如下：
s.add( x )
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
thisset = set(("CSDN", "Google", "Taobao"))
thisset.add("Facebook")
print(thisset)
# {'Taobao', 'Facebook', 'Google', 'CSDN'}
也可以添加元素，update() 将一个集合中的元素添加到另一个集合当中且参数可以是列表，元组，字典等。语法格式如下：
s.update( x )
x 可以有多个，用逗号分开。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
thisset.update({1,3})
print(thisset)
# {1, 3, 'Facebook', 'CSDN', 'Google', 'Taobao'}
thisset.update([1,4],[5,6])
print(thisset)
# {1, 3, 4, 5, 6, 'CSDN', 'Google', 'Taobao', 'Facebook'}
4.2.3 集合的删 · 移除元素
remove() 删除集合中指定的元素，语法格式如下：
s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
thisset = set(("CSDN", "Google", "Taobao"))
thisset.remove("Taobao")
print(thisset)
# {'Google', 'CSDN'}
thisset.remove("Facebook") # 不存在会发生错误
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# KeyError: 'Facebook'
此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard( x )
参考实例：
thisset = set(("Google", "CSDN", "Taobao"))
thisset.discard("Facebook") # 不存在不会发生错误
print(thisset)
# {'Google', 'CSDN', 'Taobao'}
pop() 随机删除集合中的一个元素一般是删除最后一个元素。语法格式如下：
s.pop()
参考实例：
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
# Google
clear() 清空集合，语法如下：
s.clear()
参考案例：清空集合 s。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
thisset.clear()
print(thisset)
# set()
4.2.4 集合内置方法完整列表
len() 来获取集合中元素的数量。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
print(len(thisset))
# 4
add() 向集合中添加元素。
thisset = set(("CSDN", "Google", "Taobao"))
thisset.add("Facebook")
print(thisset)
# {'Taobao', 'Facebook', 'Google', 'CSDN'}
in / not in 判断 元素是否在集合中存在。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
print("Runoob" in thisset)
# False
print("Facebook" in thisset)
# True
print("Runoob" not in thisset)
# True
print("Facebook" not in thisset)
# False
update() 将一个集合中的元素添加到另一个集合当中且参数可以是列表，元组，字典等。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
thisset.update({1,3})
print(thisset)
# {1, 3, 'Facebook', 'CSDN', 'Google', 'Taobao'}
thisset.update([1,4],[5,6])
print(thisset)
# {1, 3, 4, 5, 6, 'CSDN', 'Google', 'Taobao', 'Facebook'}
remove() 删除集合中指定的元素。
thisset = set(("CSDN", "Google", "Taobao"))
thisset.remove("Taobao")
print(thisset)
# {'Google', 'CSDN'}
thisset.remove("Facebook") # 不存在会发生错误
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# KeyError: 'Facebook'
discard( x ) 移除集合中的元素，且如果元素不存在，不会发生错误。
thisset = set(("Google", "CSDN", "Taobao"))
thisset.discard("Facebook") # 不存在不会发生错误
print(thisset)
# {'Taobao', 'Google', 'CSDN'}
pop() 随机删除集合中的一个元素一般是删除最后一个元素。
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
# Google
clear() 清空集合。
thisset = set(("CSDN", "Google", "Taobao", "Facebook"))
thisset.clear()
print(thisset)
# set()
除了以上这些之前在文章中出现过的内置方法外， Python语言 的集合还有以下这些内置方法：
copy() 拷贝一个集合
fruits = {"apple", "banana", "cherry"}
x = fruits.copy()
print(fruits,id(fruits))
# {'banana', 'cherry', 'apple'} 1796909613792
print(x,id(x))
# {'banana', 'cherry', 'apple'} 1796909613568
x.add("CSDN")
print(fruits,id(fruits))
# {'banana', 'cherry', 'apple'} 1796909613792
print(x,id(x))
# {'CSDN', 'banana', 'cherry', 'apple'} 1796909613568
difference() 返回多个集合的差集
# 返回一个集合，元素包含在集合 x ，但不在集合 y ：
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)
print(z)
# {'cherry', 'banana'}
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
# 返回一个移除的集合，元素包含在集合 x ，但不在集合 y ：
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y)
print(x)
# {'banana', 'cherry'}
intersection() 返回集合的交集
# 返回一个新集合，该集合的元素既包含在集合 x 又包含在集合 y 中：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.intersection(y)
print(z)
# {'apple'}
intersection_update() 返回集合的交集。
# 返回一个新集合，该集合的元素既包含在集合 x 又包含在集合 y 中：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.intersection_update(y)
print(x)
# {'apple'}
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
# 判断集合 y 中是否有包含 集合 x 的元素：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}
z = x.isdisjoint(y)
print(z)
# True
#-----------------------------------------------------------------
# 如果包含返回 False：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.isdisjoint(y)
print(z)
# False
issubset() 判断指定集合是否为该方法参数集合的子集。
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z)
# True
#-----------------------------------------------------------------
# 如果没有全部包含返回 False：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b"}
z = x.issubset(y)
print(z)
# False
issuperset() 判断该方法的参数集合是否为指定集合的子集
# 判断集合 y 的所有元素是否都包含在集合 x 中：
x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z)
# True
#-----------------------------------------------------------------
# 如果没有全部包含返回 False：
x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z)
# False
symmetric_difference() 返回两个集合中不重复的元素集合。
# 返回两个集合组成的新集合，但会移除两个集合的重复元素：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.symmetric_difference(y)
print(z)
# {'google', 'cherry', 'banana', 'runoob'}
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
# 在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.symmetric_difference_update(y)
print(x)
# {'google', 'cherry', 'banana', 'runoob'}
union() 返回两个集合的并集
# 合并两个集合，重复元素只会出现一次：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.union(y)
print(z)
# {'cherry', 'runoob', 'google', 'banana', 'apple'}
#-----------------------------------------------------------------
# 合并多个集合：
x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"}
result = x.union(y, z)
print(result)
# {'c', 'd', 'f', 'e', 'b', 'a'}
4.3 集合的运算
& 交集运算
s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}
result = s1 & s2
print(s1,s2,result)
# {1, 2, 3, 4, 5, 6} {3, 4, 5, 6, 7, 8} {3, 4, 5, 6}
| 并集运算
s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}
result = s1 | s2
print(result)
# {1, 2, 3, 4, 5, 6, 7, 8}
- 差集运算
s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}
-
result = s1 - s2
print(result)
# {1, 2}
^ 亦或集
# 两个集合不相交的部分
s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}
result = s1 ^ s2
print(result)
# {1, 2, 7, 8}
<= 检查一个集合是否是另一个集合的子集
< 检查一个集合是否是另一个集合的真子集
a = {1,2,3}
b = {1,2,3,4,5,6}
result = a < b # a集合是b集合的子集
print(result)
# True
result = a <= b # b集合是a集合的超集
print(result)
# True
>=检查一个集合是否是另一个集合的超集
>检查一个集合是否是另一个集合的真超集
a = {1,2,3}
b = {1,2,3,4,5,6}
result = a > b # a集合是b集合的子集
print(result)
# False
result = a >= b # b集合是a集合的超集
print(result)
# False
总结小便条
本篇文章主要讲了以下几点内容：
-
元组 的表现形式是 tuple。
1.1 Python的 元组 与 列表 类似，不同之处在于元组的元素不能修改。所以 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
1.2 元组 增·删·改·查 的操作以及Python语言自带的内置方法 这个只能靠自己 多看、多写、多体会 了。 -
Python中 数值类型（int和float）、字符串str、元组tuple 都是 不可变类型 ；而 列表list、字典dict、集合set 是 可变类型 。
2.1 可变对象中都保存了三个数据：
id(标识) type(类型) value(值)
在这里，我们说的可变变量指的是我们可以对对象里面的 value 进行改变。
2.2 对 可变对象 的四种操作方法 这个只能靠自己 多看、多写、多体会 了。 -
字典 就是 键(key)·值(value)对(key-value)
3.1 字典的语法表现形式： d = {key1 : value1, key2 : value2 }
3.2 字典 增·删·改·查 的操作以及Python语言自带的内置方法 这个只能靠自己 多看、多写、多体会 了。 -
集合表现形式：set 集合；和 列表 非常相似。
4.1 它与 列表 不同点：
1) 集合 只能存储 不可变对象；
2) 集合中存储的对象是 无序 的；
3) 集合 不能出现 重复元素。
4.2 使用大括号 { } 来创建集合；可以通过 set() 函数创建集合，或者将序列和字典 转换成 集合。
注意：创建一个 空集合 必须用 set() ，而不是 { }。因为 { } 是用来创建一个 空字典 的。
4.3 集合 增·删·改·查 的操作以及Python语言自带的内置方法 这个只能靠自己 多看、多写、多体会 了。
本章回顾暂时就到这了，如果还有点晕，那就去完成作业吧。拜拜~
作业
1. 上文中讲到的函数以及代码再练习几遍；
2. 从 a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到 python1/python2/python3
3. 有如下集合{11, 22, 33, 44, 55, 66, 77, 88, 99}，将所有 大于66的值 保存至字典的第一个key中，将所有 小于66的值 保存至字典的第二个key中；
4. 将字符串中的空格替换成“%20”
参考答案
# 作业 2
a = {"name":"qwe","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}
# 提取 python1 , python2 , python3
# data ---> {"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}
# result ---> [{"src":"python1"},{"src":"python2"},{"src":"python3"}]
# 方法 1
b = a['data']
c = b['result']
for i in c:
print(i['src'])
# python1
# python2
# python3
# 方法 2
b = a['data']['result']
for x in b:
print(x['src'])
# python1
# python2
# python3
#-----------------------------------------------------------------------------------
# 作业 3 # 原理我懂，但最初我就是没有有做出想要的结果。为什么呢。因为我忘记了 append 和 update 这两个内置函数。
i = {11, 22, 33, 44, 55, 66, 77, 88, 99}
dic = {}
m = []
n = []
for x in i:
if x > 66:
m.append(x)
else:
n.append(x)
dic.update(k1 = m, k2 = n)
print(dic)
#-----------------------------------------------------------------------------------
# 作业 4
# 将字符串中的空格替换成“%20”
# 方法一：
strs = 'hello my baby'
def rep(a):
li = []
for i in a:
li.append(i)
for i in range(len(li)):
if li[i] == ' ':
li[i] = '%20'
return ''.join(li)
sa = rep(strs)
print(sa)
# 方法二：
def rep(a):
li = []
for i in a:
li.append(i)
for i in li:
if i == ' ':
li[li.index(i)] = '%20'
return ''.join(li)
sb = rep(strs)
print(sb)