【Python百日基础系列】Day03 - Python 数据类型

视频讲解1：数据类型 数字 字符串 列表

D03-Python数据类型 01 简介 数字 字符串 列表

视频讲解2：元组 字典 集合

Day03-Python数据类型 02 元组 字典 集合

一、Python中的数据类型

1.1 数据类型系统是编程语言的核心

数据类型一般指数据元。数据元( Data Element)，也称为数据元素，是用一组属性描述其定义、标识、表示和允许值的数据单元，在一定语境下，通常用于构建一个语义正确、独立且无歧义的特定概念语义的信息单元。数据元可以理解为数据的基本单元。

1.2 Python中的数据类型种类

Python 3 中有六个标准的数据类型：

• Number（数字）：数字类型是顾名思义是用来存储数值的，包括int(整型)、float(浮点型)、bool(布尔型)和complex（复数）。
• String（字符串）：引号包裹的一串字符。
• List（列表）：中括号[]包裹的，逗号分隔的元素序列。
• Tuple（元组）：小括号()包裹的，逗号分隔的元素序列。元组不能修改，元组的元素不能重复。
• Sets（集合）：大括号{}包裹的，逗号分隔的元素序列。集合的元素不能重复。
• Dictionary（字典）：字典是一种映射类型，它的元素是键值对，字典的键必须为不可变数据类型且不能重复。

1.3 数据类型的可变性

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Set（集合）、Dictionary（字典）。

1.4 数据类型查看函数 - type()

1. 查看对象类型：type(obj)
2. 判断对象是否为某种类型：type(obj) == int / str / tuple / list /set / dict

二、Number - 数字

数字视频讲解：

2.1 整型(int)

通常被称为是整型或整数，是正或负整数，不带小数点。Python 3 整型是没有限制大小的。

a = 100
a = 12345 ** 123
print(a)
print(type(a))
print(type(a) == int)

输出结果：
179227478536797075276952162319434197129926964430623405351403914666844095303193142386105303128935260661331482166609669142646381589155256961299625923906846736377224598990446854741893321648522851663303862851165879753724272728386042804116173040017014488023693807547724950916588058455499429272048326934098750367364004488112819439755556403443027523561951313385041616743787240003466700321402142800004483416756392021359457461719905854364181525061772982959380338841234880410679952689179117442108690738677978515625
<class 'int'>
True

2.2 浮点型(float)

浮点型由整数部分与小数部分组成

a = 100.3
a = 12345.5 ** 12.3
print(a)
print(type(a))
print(type(a) == float)

输出结果：
2.1162004909718374e+50
<class 'float'>
True

2.3 布尔型(bool)

bool 类型就是用于代表某个事情的真（对）或假（错），如果这个事情是正确的，用 True（或 1）代表；如果这个事情是错误的，用 False（或 0）代表。
布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。

a = 2 > 1
print(a)
print(type(a))
print(type(a) == bool)
print(a + 2)
print(True + 2)
print((not a) - 10)
print(False - 10)

输出结果：
True
<class 'bool'>
True
3
3
-10
-10

2.4 复数(complex)

复数由实数部分和虚数部分构成，可以用 a+bj 或者 complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

a = 123 - 12j
print(a.real)  # 实部
print(a.imag)  # 虚部

输出结果：
123.0
-12.0

2.5 数字类型转换函数

1. 转为整型：int()
2. 转为浮点型：float()
3. 转为布尔型：bool()，0为False，其他均为True
4. 转为复数型：complex()

print(int(123.56))
print(float(123))
print(bool(10.5))
print(bool(-10.5))
print(bool(0))
print(complex(123))
print(complex(123, 56))

输出结果：
123
123.0
True
True
False
(123+0j)
(123+56j)

2.6 数字运算

数字运算包括:

• 加：+
• 减：-
• 乘：*
• 除：/
• 整除：//
• 取余：%，不同于除法和整除，取余结果的符号与被除数保持一致
• 乘方：**

print(5 + 4)    # 加法，输出 9
print(4.3 - 2)  # 减法，输出 2.3
print(3 * 7)    # 乘法，输出 21
print(6 / 2)    # 除法，得到一个浮点数  输出 3.0
print(6 // 2)   # 整除，得到一个整数 输出 3
print(17 % 3)   # 取余，输出 2
print(17 % -3)   # 取余，输出 -1
print(-5 % -2)  # 取余，输出 -1
print(2 ** 5)   # 乘方，输出 32

三、String - 字符串

3.1 字符串的定义

字符串的定义可以使用单引号、双引号、三单引号和三双引号，其中三引号可以多行定义字符串。

s1 = '我是单引号定义的字符串'
s2 = "我是双引号定义的字符串"
s3 = '''我是三单引号定义的字符串，
可以输入好多行
！！！'''
s4= """我是三双引号定义的字符串
可以输入好多行\
！！！"""

print(s1)
print(s2)
print(s3 + '\n')
print(s4)

输出结果：
我是单引号定义的字符串
我是双引号定义的字符串
我是三单引号定义的字符串，
可以输入好多行
！！！

我是三双引号定义的字符串
可以输入好多行！！！

3.2 字符串的常用操作

1. 字符串的长度：len(str)
2. 字符串的连接：+
3. 字符串的重复：*
4. 字符串的切片：[]
5. 字符串的分隔：str.split()
6. 字符串的替换：str.replace()
7. 字符串的查找：str.find()，str.index()

s1 = 'Hello '
s2 = 'world'
print(len(s1))
print(s1 + s2)  # 连接
print(s1 * 3)   # 重复
print(s1[0], s1[2], s1[-1])  # 单个切片
print(s1[0:2], s1[:2], s1[1:-1], s1[1:])  # 连续切片
print(s2[0:4:2], s2[::-1])  # 步长切片
print(s2.split('r'))        # 分割结果为列表['wo', 'ld']
print(s1.replace('H', 'h'))  # 替换
print(s1.find('l'))  # 查找第一个l
print(s1.find('l', s1.find('l')+1))  # 从第一个l后索引开始查找第一个l
print(s1.find('abc'))  # 找不到返回-1
print(s1.index('l'))  # 查找第一个l,能找到同find
print(s1.index('abc'))  # 找不到抛出ValueError

输出结果：
6
Hello world
Hello Hello Hello 
H l  
He He ello ello 
wr dlrow
['wo', 'ld']
hello 
2
3
-1
2
Traceback (most recent call last):
  File "E:\python_100\py_100\Day03 - Python 数据类型.py", line 78, in <module>
    print(s1.index('abc'))  # 找不到抛出ValueError
ValueError: substring not found

6. 字符串大小转换和判断, upper()、lower()、swapcase()、capitalize()、istitle()、isupper()、islower()

s1 = 'Hello '
s2 = 'world'
print(s1.upper())       # 转大写
print(s1.lower())       # 转小写
print(s1.swapcase())    # 大小写交换
print(s2.capitalize())  # 首字母大写
print(s1.istitle())     # 判断是否是首字母大写的样式
print(s1.isupper())     # 判断是否全为大写
print(s1.islower())     # 判断是否全为小写

输出结果：
HELLO 
hello 
hELLO 
World
True
False
False

7. 字符串去除首尾空格,strip()、lstrip()、rstrip()

s1 = 'Hello '
s2 = 'world'
print(s1.strip(), len(s1.strip()))  # 去除首尾空格
print(s1.lstrip(), len(s1.lstrip()))  # 去除首空格
print(s1.rstrip(), len(s1.rstrip()))  # 去除尾空格

输出结果：
Hello 5
Hello  6
Hello 5

8. 字符串格式化输出，有%、.format和f字符串三种方法，第三种最简单、可读性强，此处只介绍第三种

name = 'Tom'    # 字符串
age = 18        # 整型
print(f'我是:{name},今年{age}岁。')

输出结果：
我是:Tom,今年18岁。

3.3 字符串的转码

1. encode 将字符转换为字节
2. decode 将字节转换为字符

s1 = '你好，Tom！'
print(s1.encode())  # 转换为字节，默认编码utf-8
print(s1.encode('utf-8'))  # 转换为字节，默认编码utf-8
print(s1.encode('gbk'))  # 转换为字节，编码gbk
print('前后默认编码', s1.encode().decode())  # 转换为字节，再转回字符串，默认编码utf-8
print('前默认，后utf-8', s1.encode().decode('utf-8'))  # 转换为字节，再转回字符串，默认编码utf-8
print('前后gbk', s1.encode('gbk').decode('gbk'))  # 转换为字节，再转回字符串，编码gbk
print('前gbk，后utf-8', s1.encode('gbk').decode())  # 转换为字节，再转回字符串，编码gbk

输出结果：
b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8cTom\xef\xbc\x81'
b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8cTom\xef\xbc\x81'
b'\xc4\xe3\xba\xc3\xa3\xacTom\xa3\xa1'
前后默认编码 你好，Tom！
前默认，后utf-8 你好，Tom！
前后gbk 你好，Tom！
Traceback (most recent call last):
  File "E:\python_100\py_100\Day03 - Python 数据类型.py", line 111, in <module>
    print('前gbk，后utf-8', s1.encode('gbk').decode())  # 转换为字节，再转回字符串，编码gbk
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 in position 0: invalid continuation byte

四、List - 列表

列表是Python最常用的数据类型，它由中括号[]和内部用逗号分隔的元素组成。

• 列表的元素不需要具有相同的类型
• 列表的元素可以重复
• 列表的元素是有序的，列表的每个元素对应一个隐含的索引值，从0开始。

4.1 列表的定义

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

4.2 列表的常用操作

1. 列表的连接：+
2. 列表的重复：*
3. 列表的切片：[]
4. 列表的成员运算：in
5. 列表的迭代：for

lst1 = ['1', '8', 'x', 'A', '5']
lst2 = [200, 10.5, True, 123+12j, 'Tom', lst1, (1, 2, 3), {1, 2, 3}, {'name': 'Tom', 'age': 18}]
print(lst2)       # 查看定义的列表
print(lst1 + lst2)      # 列表元素的连接，元素级操作
print(lst1 * 3)         # 列表元素的重复，元素级操作
print(lst2[-4:])        # 列表的切片，操作同字符串
print(lst2[::-1])
print('1' in lst1)      # 成员运算
print('--------------')
for item in lst2:       # 列表迭代
    print(item)

输出结果：
[200, 10.5, True, (123+12j), 'Tom', ['1', '8', 'x', 'A', '5'], (1, 2, 3), {1, 2, 3}, {'name': 'Tom', 'age': 18}]
['1', '8', 'x', 'A', '5', 200, 10.5, True, (123+12j), 'Tom', ['1', '8', 'x', 'A', '5'], (1, 2, 3), {1, 2, 3}, {'name': 'Tom', 'age': 18}]
['1', '8', 'x', 'A', '5', '1', '8', 'x', 'A', '5', '1', '8', 'x', 'A', '5']
[['1', '8', 'x', 'A', '5'], (1, 2, 3), {1, 2, 3}, {'name': 'Tom', 'age': 18}]
[{'name': 'Tom', 'age': 18}, {1, 2, 3}, (1, 2, 3), ['1', '8', 'x', 'A', '5'], 'Tom', (123+12j), True, 10.5, 200]
True
--------------
200
10.5
True
(123+12j)
Tom
['1', '8', 'x', 'A', '5']
(1, 2, 3)
{1, 2, 3}
{'name': 'Tom', 'age': 18}

4.3 列表的常用函数

1. len(lst)：列表元素个数
2. max(lst)：返回列表元素最大值
3. min(lst)：返回列表元素最小值
4. list(seq)：将元组、集合转换为列表

lst1 = ['1', '8', 'x', 'A', '5']
lst2 = [200, 10.5, True, 123+12j, 'Tom', lst1, (1, 2, 3), {1, 2, 3}, {'name': 'Tom', 'age': 18}]
print(len(lst1), len(lst2))     # 查看列表元素个数（长度）
print(max(lst1))
print(min(lst1))
print(list((1, 2, 3)), list({1, 2, 3}))

输出结果：
5 9
x
1
[1, 2, 3] [1, 2, 3]

4.4 列表的常用方法

1. lst.append(obj)：在列表末尾添加新的对象
2. lst.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
3. lst.insert(index, obj)：将对象插入列表
4. lst.remove(obj)：按值删除元素，无返回值
5. lst.pop([index=-1])：按索引移出元素（默认最后一个元素），返回移出的元素
6. del lst[index]：# 按索引删除元素
7. lst.index(obj)：从列表中找出某个值第一个匹配项的索引位置
8. lst.count(obj)：统计某个元素在列表中出现的次数
9. lst.reverse()：反向列表中元素
10. lst.sort(cmp=None, key=None, reverse=False)：对原列表进行排序

lst1 = ['1', '8', 'x', 'A', 5]
lst2 = [200, 5, 10]
lst1.append(lst2)
print(lst1)
lst1.extend(lst2)
print(lst1)
lst1.insert(2, 200)
print(lst1)
print('----------------')
res = lst1.remove(200)      # 按值删除元素，无返回值
print(lst1)
print(res)
res = lst1.pop(2)       # 按索引移出元素，返回移出的元素
print(lst1)
print(res)
del lst1[2]             # 按索引删除元素
print(lst1)
print('==============')
print(lst1.index(5))
print(lst1.count(5))
lst1.reverse()
print(lst1)
lst2.sort()
print(lst2)

输出结果：
['1', '8', 'x', 'A', 5, [200, 5, 10]]
['1', '8', 'x', 'A', 5, [200, 5, 10], 200, 5, 10]
['1', '8', 200, 'x', 'A', 5, [200, 5, 10], 200, 5, 10]
----------------
['1', '8', 'x', 'A', 5, [200, 5, 10], 200, 5, 10]
None
['1', '8', 'A', 5, [200, 5, 10], 200, 5, 10]
x
['1', '8', 5, [200, 5, 10], 200, 5, 10]
==============
2
2
[10, 5, 200, [200, 5, 10], 5, '8', '1']
[5, 10, 200]

五、Tuple - 元组

5.1 元组的定义

1. Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号 ( )，列表使用方括号 [ ]。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tuple = ("google", "Runoob", "Taobao")
print(tuple)
print(type(tuple))

输出结果：
('google', 'Runoob', 'Taobao')
<class 'tuple'>

元组不能修改

tp = ("google", "Runoob", "Taobao", 100, 200.5, [1, 2, 3])
lst = list(tp)
lst[0] = 'first'
print(lst)
tp[0] = 'first'
print(tp)

输出结果：
['first', 'Runoob', 'Taobao', 100, 200.5, [1, 2, 3]]
Traceback (most recent call last):
  File "E:\python_100\py_100\03.py", line 5, in <module>
    tp[0] = 'first'
TypeError: 'tuple' object does not support item assignment

2. 创建空元组：tp = ()
3. 创建单元素元组，必须在元素后面加一个逗号，否则括号会被当作运算符使用。这一点与列表不同，列表可加可不加。

tp = (50)
print(tp, type(tp))
tp1 = (50,)
print(tp1, type(tp1))

输出结果：
50 <class 'int'>
(50,) <class 'tuple'>

5.2 元组的索引

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

5.3 访问元组

和列表一样，元组可以使用下标索引来访问元组中的值

tp = ("google", "Runoob", "Taobao", 100, 200.5, [1, 2, 3])
print(tp[2])
print(tp[-1][1])
print(tp[::-1])

输出结果：
Taobao
2
([1, 2, 3], 200.5, 100, 'Taobao', 'Runoob', 'google')

5.4 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，其实是删除变量

tp = ('单元素元组',)
del tp
print(tp)

输出结果：
Traceback (most recent call last):
  File "E:\python_100\py_100\03.py", line 3, in <module>
    print(tp)
NameError: name 'tp' is not defined

5.5 元组运算操作

与字符串一样，元组之间可以使用 + 号和 * 号进行运算，运算后会生成一个新的元组。

1. 连接：+
2. 复制：*
3. 成员运算：in
4. 循环迭代：for

tp1 = ("google", "Runoob", "Taobao", 100, 200.5, [1, 2, 3])
tp2 = ('单元素元组',)
tp3 = tp1 + tp2
print(tp3)
tp4 = tp2 * 3
print(tp4)
print(100 in tp1)
print(100 in tp2)
print('--------------------')
for item in tp1:
    print(item)

输出结果：
('google', 'Runoob', 'Taobao', 100, 200.5, [1, 2, 3], '单元素元组')
('单元素元组', '单元素元组', '单元素元组')
True
False
--------------------
google
Runoob
Taobao
100
200.5
[1, 2, 3]

5.6 元组的常用函数

与列表同名函数功能完全一样

1. len(tuple)：计算元组元素个数。
2. max(tuple)：返回元组中元素最大值。
3. min(tuple)：返回元组中元素最小值。
4. tuple(iterable)：将可迭代系列转换为元组。

tp = ("google", "Runoob", "Taobao")
lst = [1, 2, 3]
print(len(tp),)
print(max(tp))
print(min(tp))
print(tuple(lst))

输出结果：
3
google
Runoob
(1, 2, 3)

5.7 元组常用方法

1. tuple.count()：统计元组中指定值的个数
2. tuple.index()：查找指定值在元组中的索引，不存在会报错

tp = ("google", "Runoob", "Taobao")
print(tp.count('google'))
print(tp.index('google'))
print(tp.index('a'))

输出结果：
1
0
Traceback (most recent call last):
  File "E:\python_100\py_100\03.py", line 4, in <module>
    print(tp.index('a'))
ValueError: tuple.index(x): x not in tuple

六、Dictionary - 字典

字典也是Python中的常用类型，因为字典key的唯一性，可以按key索引，所以对于大量数据，字典的运算速度远高于列表和元组这种无序序列。
整个字典包括在花括号 {} 中，由>=0个键值对组成；每个键值对的key和value中间用冒号 : 分割；若干键值对之间用逗号(,)分割，形如：
d = {key1 : value1, key2 : value2, key3 : value3 }

6.1 字典的定义

1. 字典的key需要满足两个条件：

• 必须是不可变数据类型，如字符串、数字和元组，最常用的是字符串。
• 唯一性，不能重复。

2. 字典的value没有要求，可以是任意数据类型，并且可以嵌套。
3. 定义空字典

dt1 = { 'abc': 456, 'abc': 789}
dt2 = { 'abc': 123, 98.6: 37, (1, 2): (1, 2) }
dt3 = {'name': 'Tom',
       'sex': 'male',
       'age': 18,
       'likes': {1: 'study', 2: 'play'},
       'address': ['Shandong', 'China']}
u4 = {}
print(dt1)
print(dt2)
print(dt3)
print(u4, type(u4))

输出结果：
{'abc': 789}
{'abc': 123, 98.6: 37, (1, 2): (1, 2)}
{'name': 'Tom', 'sex': 'male', 'age': 18, 'likes': {1: 'study', 2: 'play'}, 'address': ['Shandong', 'China']}
{} <class 'dict'>

6.2 访问字典

1. 访问字典的键列表
2. 访问字典的值列表
3. 按键取值

dt = {'name': 'Tom',
     'sex': 'male',
     'age': 18,
     'likes': {1: 'study', 2: 'play'},
     'address': ['Shandong', 'China']}
print(dt.keys())
print(type(dt.keys()))
print(list(dt.keys()))
print('-------------')
print(dt.values())
print(type(dt.values()))
print(list(dt.values()))
print('------------')
print(dt['name'], dt['likes'])
print(dt['score'])

输出结果：
dict_keys(['name', 'sex', 'age', 'likes', 'address'])
<class 'dict_keys'>
['name', 'sex', 'age', 'likes', 'address']
-------------
dict_values(['Tom', 'male', 18, {1: 'study', 2: 'play'}, ['Shandong', 'China']])
<class 'dict_values'>
['Tom', 'male', 18, {1: 'study', 2: 'play'}, ['Shandong', 'China']]
------------
Tom {1: 'study', 2: 'play'}
Traceback (most recent call last):
  File "E:\python_100\py_100\03.py", line 15, in <module>
    print(dt['score'])
KeyError: 'score'

6.3 修改字典

1. 新增键值对
2. 按键修改值

dt = {'name': 'Tom',
     'sex': 'male',
     'age': 18,}
print(dt)
dt['score'] = 100
print(dt)
dt['age'] = 20
print(dt)

输出结果：
{'name': 'Tom', 'sex': 'male', 'age': 18}
{'name': 'Tom', 'sex': 'male', 'age': 18, 'score': 100}
{'name': 'Tom', 'sex': 'male', 'age': 20, 'score': 100}

6.4 删除字典

1. 删除一个键值对
2. 清空字典
3. 删除字典变量

dt = {'name': 'Tom',
     'sex': 'male',
     'age': 18,}
del dt['age']
print(dt)
dt.clear()
print(dt)
del dt
print(dt)

输出结果：
{'name': 'Tom', 'sex': 'male'}
{}
Traceback (most recent call last):
  File "E:\python_100\py_100\03.py", line 9, in <module>
    print(dt)
NameError: name 'dt' is not defined

6.5 字典相关函数

1. len(dict)：返回字典元素个数（长度）
2. str(dict)：返回字典字符串

dt = {'name': 'Tom',
     'sex': 'male',
     'age': 18,}
print(len(dt))

if type(dt) == dict:
    print(dt, len(dt))
    
if type(str(dt)) != str:
    print('str(dt) 不是字符串！')
else:
    print('str(dt)是字符串！')
    print(str(dt), len(str(dt)))

输出结果：
3
{'name': 'Tom', 'sex': 'male', 'age': 18} 3
str(dt)是字符串！
{'name': 'Tom', 'sex': 'male', 'age': 18} 41

6.6 字典相关方法

1. key in dict：成员运算
2. dict.get(key)：按键取值

dt = {'name': 'Tom',
     'sex': 'male',
     'age': 18,}
print('name' in dt)
print('score' in dt)
print(dt.get('age'))

输出结果：
True
False
18

七、Sets - 集合

集合（set）是一个无序的不重复元素序列。集合中的元素会随机排列，与输入顺序无关。

7.1 集合定义

1. 非空集合用{value,…}定义，或者用set()来转换，set()仅接受一个参数
2. 空集合必须用set()定义，因为{}定义的是空字典

st1 = set('abc')
print(st1)
st2 = {'abc', 456, 789}
print(st2)
st3 = { 'abc', 123, 98.6, 37, (1, 2), (1, 2) }
print(st3)
st4 = {}
print(st4, type(st4))
st5 = set('abc', 456, 789)

输出结果：
{'a', 'c', 'b'}
{456, 789, 'abc'}
{98.6, (1, 2), 37, 123, 'abc'}
{} <class 'dict'>
Traceback (most recent call last):
  File "E:\python_100\py_100\03.py", line 9, in <module>
    st5 = set('abc', 456, 789)
TypeError: set expected at most 1 argument, got 3

7.2 集合的常用操作

1. 成员运算：in
2. 并集运算：| 或 st1.union(st2)
3. 交集运算：& 或 st1.intersection(st2)
4. 差集运算：- 或 st1.difference(st2)
5. 对称差集：^ 或 st1.symmetric_difference(st2)
   

st1 = set('abcdr')
st2 = set('aclmz')
print(st1, st2)
print('并集', st1 | st2, st1.union(st2))
print('交集',st1 & st2, st1.intersection(st2))
print('差集',st1 - st2, st1.difference(st2))
print('对称差集',st1 ^ st2, st1.symmetric_difference(st2))

输出结果：
{'b', 'd', 'c', 'a', 'r'} {'c', 'a', 'l', 'z', 'm'}
并集 {'b', 'd', 'c', 'a', 'l', 'r', 'z', 'm'} {'b', 'd', 'c', 'a', 'l', 'r', 'z', 'm'}
交集 {'c', 'a'} {'c', 'a'}
差集 {'b', 'd', 'r'} {'b', 'd', 'r'}
对称差集 {'b', 'd', 'z', 'l', 'm', 'r'} {'b', 'd', 'z', 'l', 'm', 'r'}

7.4 集合的常用函数

1. len(s)：集合元素个数（长度）

7.4 集合的常用方法

1. 添加单个元素：s.add(x)，参数可以是任意数据类型
2. 添加多个元素：s.update(x,…)，参数可以是字符串、列表、元组、字典、集合等可迭代对象，不能是数字。会先迭代出所有底层元素，再添加。
3. 移除一个元素：s.remove(x)，如果元素不存在会报错
4. 移除一个元素：s.discrd(x)，如果元素不存在会报错，不做任何操作
5. 随机移除一个元素：s.pop()，不接受任何参数
6. 清空集合：s.clear()

st1 = {'abc', 456,}
st1.add('789')
print(st1)
st1.update('100', [1, 2], (8, 9), {'name': 'tom'},{'hello'})
print(st1)
st1.remove('abc')
print(st1)
st1.discard('abc')
print(st1)
st1.pop()
print(st1)
st1.clear()
print(st1)

输出结果：
{456, 'abc', '789'}
{1, 2, 456, 8, 9, 'hello', 'name', '789', '1', '0', 'abc'}
{1, 2, 456, 8, 9, 'hello', 'name', '789', '1', '0'}
{1, 2, 456, 8, 9, 'hello', 'name', '789', '1', '0'}
{2, 456, 8, 9, 'hello', 'name', '789', '1', '0'}
set()