锐客网

  1. 首页 > it技术 > >

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

Python


文章目录

    • 一、Python中的数据类型
      • 1.1 数据类型系统是编程语言的核心
      • 1.2 Python中的数据类型种类
      • 1.3 数据类型的可变性
      • 1.4 数据类型查看函数 - type()
    • 二、Number - 数字
      • 2.1 整型(int)
      • 2.2 浮点型(float)
      • 2.3 布尔型(bool)
      • 2.4 复数(complex)
      • 2.5 数字类型转换函数
      • 2.6 数字运算
    • 三、String - 字符串
      • 3.1 字符串的定义
      • 3.2 字符串的常用操作
      • 3.3 字符串的转码
    • 四、List - 列表
      • 4.1 列表的定义
      • 4.2 列表的常用操作
      • 4.3 列表的常用函数
      • 4.4 列表的常用方法
    • 五、Tuple - 元组
      • 5.1 元组的定义
      • 5.2 元组的索引
      • 5.3 访问元组
      • 5.4 删除元组
      • 5.5 元组运算操作
      • 5.6 元组的常用函数
      • 5.7 元组常用方法
    • 六、Dictionary - 字典
      • 6.1 字典的定义
      • 6.2 访问字典
      • 6.3 修改字典
      • 6.4 删除字典
      • 6.5 字典相关函数
      • 6.6 字典相关方法
    • 七、Sets - 集合
      • 7.1 集合定义
      • 7.2 集合的常用操作
      • 7.4 集合的常用函数
      • 7.4 集合的常用方法

视频讲解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 True

2.2 浮点型(float)
浮点型由整数部分与小数部分组成
a = 100.3 a = 12345.5 ** 12.3 print(a) print(type(a)) print(type(a) == float)输出结果： 2.1162004909718374e+50 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 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 print(s1.index('abc'))# 找不到抛出ValueError ValueError: substring not found

  1. 字符串大小转换和判断, 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

  1. 字符串去除首尾空格,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 Hello6 Hello 5

  1. 字符串格式化输出，有%、.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 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')

元组不能修改
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 tp[0] = 'first' TypeError: 'tuple' object does not support item assignment

Python|【Python百日基础系列】Day03 - Python 数据类型
文章图片

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

5.2 元组的索引
元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。
Python|【Python百日基础系列】Day03 - Python 数据类型
文章图片

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 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 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 }
Python|【Python百日基础系列】Day03 - Python 数据类型
文章图片

6.1 字典的定义
  1. 字典的key需要满足两个条件：
  • 必须是不可变数据类型，如字符串、数字和元组，最常用的是字符串。
  • 唯一性，不能重复。
  1. 字典的value没有要求，可以是任意数据类型，并且可以嵌套。
  2. 定义空字典
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']} {}

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']) ['name', 'sex', 'age', 'likes', 'address'] ------------- dict_values(['Tom', 'male', 18, {1: 'study', 2: 'play'}, ['Shandong', 'China']]) ['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 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 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 - 集合 【Python|【Python百日基础系列】Day03 - Python 数据类型】集合（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'} {} Traceback (most recent call last): File "E:\python_100\py_100\03.py", line 9, in 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)
    Python|【Python百日基础系列】Day03 - Python 数据类型
    文章图片
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()

    推荐阅读


    上一篇：spring|Java最全面试题之Spring篇

    下一篇：概率论|【概率论基础】标本空间与事件 | Sample Space and Event