Python数据类型内置方法
【目录总结】
-
int整数型
- 类型转换
- 进制转换：int(原始数据，原始数据进制)， hex(十进制)，oct(十进制)，bin(二进制)
- str->int：小数会报错
- float->int：精度损失
- 常用函数
- isdigit：所有字符都是数字
- isdecimal：字符是十进制数字
- isnumeric：所有字符是数字
- 类型转换
-
float浮点型
- 类型转换：
- int->float：自动补0
- 取整函数：round()
- 类型转换：
-
str字符串
- 类型转换：其他都可以转字符串
- 增：
- 拼接+
- 删：
- strip()：默认去除空格
- 改：
- replace(old, new)
- 查：
- 索引取值，切片，不能修改
- 其他：
- len 个数
- in 成员
- split 切分
- lower，upwer，大小写转换
- swapcase， 大小写翻转
- captalize， 第一行首字母大写
- title，所有单词首字母大写
- expendtabs，制表符修改
-
list列表
- 类型转换：能被for循环的数据类型
- 增：
- 拼接+
- append,当成整体传入
- extend，可拆分后传入
- insert，索引位置，整体传入
- 删：没有会报错
- del，索引位置
- pop，索引值，默认最后一个，有返回值
- remove，值，没有会报错
- 改：
- 索引改，切片改
- 查：
- 索引取值，切片，
- 其他：
- len 个数
- in 成员
- reverse， 成员顺序颠倒
- sort，默认升序，原表改
- sorted，建新表排序
-
tuple元组
- 类型转换：能被for循环的数据类型
- 增：
- 拼接+
- 删：不能删
- 改：不能修改
- 查：
- 索引取值，切片，
- 其他：
- len 个数
- in 成员
-
bool布尔
- 真：非零数字、非空字符串、非空列表、非空字典、非空集合
- 假：零数字、空字符串、空列表、空字典、空集合
-
dict字典
- 增：
- 直接添加，dict[key] = value
- update({key:value})，批量更新和添加
- setdefault(key,value), 有返回值value
- 删：没有会报错
- del dict[key]
- dict.pop(key)，有返回值，是值
- clear，清空
- popitem，随机删除键值对，元组形式返回键值对
- 改：
- 直接改，dict[key] = value
- update({key:value})，批量更新和添加
- setdefault(key,value), 有返回值value
- 查：返回的都是可迭代对象
- dict.keys()
- dict.values()
- dict.items()
- 其他：
- len 个数
- in 成员
- reverse， 成员顺序颠倒
- sorted(dict)，建新字典排序
- 增：
-
set集合
-
类型转换
- str->set
- dict->dict, dict.values->dict
- tuple->set
-
增：
- 拼接+
- add 单个元素
- update 多个元素，元素是可迭代对象
-
删：
-
pop 伪随机删除一个，有返回值，没有会报错
-
remove，值，没有会报错
-
discard， 值，没有不会报错
-
-
改：删除后再增增加
-
查：没有
-
其他：
- len 个数
- in 成员
- union，intersection，difference
- issuperset，issubset
-
【一】数字类型
【1】整数类型(int)
（1）整数类型定义
- 整数类型是Python中的一种基本数据类型，用于表示整数。
- 在Python中，整数类型是不可变的，即一旦创建，其值不能被修改。
num = 100
（2）类型强转（str–>int）
- 可以将由纯整数构成的字符串直接转换成整型
- 若包含其他任意非整数符号会报错
a = '1'
res = int(a)
print(a, type(a)) # 1 （3）进制转换
- 十进制–>二进制 bin()
num = 100
print(bin(num)) #0b1100100
- 十进制–>八进制 oct()
num = 100
print(oct(num)) #0o144
- 十进制–>八进制 hex()
num = 100
print(hex(num)) #0x64
-
其他进制转十进制
-
int()函数支持将不同进制的字符串转换为十进制整数。主要的进制包括：- 二进制（以 ‘0b’ 或 ‘0B’ 开头） B：binary
- 八进制（以 ‘0o’ 或 ‘0O’ 开头） O：octal
- 十六进制（以 ‘0x’ 或 ‘0X’ 开头） H：hexadecimal
binary = '0b1100100'
num = int(binary, 2)
octal = '0o144'
num = int(octal, 8)
hexadecimal = '0x64'
num = int(hexadecimal, 16)
- 在这些例子中，字符串的前缀表明了不同的进制
【2】浮点类型(float)
（1）浮点类型定义
- 浮点类型是一种表示有小数部分的数字的数据类型。
- 在Python中，可以使用小数点表示浮点数。
doller = 11.11
（2）取整函数（round）
round(3.14159) #3
（4）类型强转
# 将整数转换为浮点数
num_int = 100
num_float = float(num_int) #100.0
# 将浮点数转换为整数
num_float = 3.14
num_int = int(num_float) #3 存在精度损失
【3】判断数字类型
（1）数字类型说明
num1 = b'4' # bytes
num2 = '4' # unicode，Python 3 中不需要在字符串前加 'u'
num3 = '四' # 中文数字
num4 = 'Ⅳ' # 罗马数字
（2）isdigit（）
- 如果所有字符都是数字，并且至少有一个字符，则返回True。
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False
（3）isdecimal（）
- 如果只有十进制字符，则返回True，否则为False
# bytes类型没有isdecimal方法
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False
（4）isnumeric（）
- 如果只有数字字符，则返回True，否则为False。
# bytes类型没有isnumeric方法）
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True
（5）无法判断浮点数
# 这三种方法无法判断浮点数
num5 = '4.3'
print(num5.isdigit()) # False
print(num5.isdecimal()) # False
print(num5.isnumeric()) # False
【三】字符串类型(str)
【1】字符串类型定义
- 字符串是由字符组成的，可以包含字母、数字、标点符号、空格等字符。
- 在Python中，字符串类型使用单引号、双引号和三引号来定义。
# 使用单引号定义字符串
str1 = 'Hello, World!'
# 使用双引号定义字符串
str2 = "Hello, Python!"
# 使用三引号定义字符串
str3 = '''
This is a multi-line
string in Python.
'''
【2】内置方法(学会)
（1）字符串拼接(+)
- 字符串拼接是将多个字符串连接在一起形成一个新的字符串。
str1 = 'Hello,'
str2 = 'World!'
result_str = str1 + ' ' + str2
（2）索引取值(只能取值，不能修改)
text = 'Python'
first_char = text[0] #p 正索引取值
last_char = text[-1] #n 反索引取值
text[0]='H' #报错
（3）切片（ [ ) ）
# 顾头不顾尾
text = 'Python'
substring = text[1:4] # yth
# 步长
text = 'Python'
substring = text[0:4:2] # Pt (步长为2，及间隔为1)
#反向切片
text = 'Python'
substring = text[-1:-4:-2] # nh (即使区间已经颠倒，步长仍需为负)
（4）计算长度(len)
text = 'Hello, World!'
length = len(text) #13
（5）成员运算
in和not in用于检查一个字符串是否包含另一个字符串
text = 'Python'
'Py' in text #True
'py' not in text #True
（6）去除空格(strip)(常用)
# 默认情况下，trip方法会去除字符串开头和结尾的所有空格。
text = ' Hello, World! '
strip_text = text.strip() # Hello, World!
# lstrip方法用于去除字符串开头的空格。
text = ' Hello, World! '
lstrip_text = text.lstrip() # Hello, World!____
# rstrip方法用于去除字符串结尾的空格。
text = ' Hello, World! '
rstrip_text = text.rstrip() # _____Hello, World!
# 去除指定字符
text = '<>'
stripped_text = text.strip('<>') # Hello, World!
- 这些方法在处理用户输入、文件读取等场景中经常用到，可以有效地清理字符串的格式
（7）切分(split)(常用)
# 默认使用空格或者换行作为切分符
text = 'Hello, World!'
split_result = text.split() # ['Hello,', 'World!']
# 指定分隔符
text = 'Hello, World!'
split_result = text.split(',') # ['Hello', ' World!']
（8）遍历字符串
- 使用
for循环可以遍历字符串中的每个字符
text = 'Hello'
for char in text:
print(char)
（9）字符串重复
- 使用
*运算符可以实现字符串的重复
original_str = 'ABC'
repeated_str = original_str * 3 # ABCABCABC
（10）大小写转换(常用于登录系统)
# 将给定字符串中的所有字母变为大写
text = 'hello'
upper_text = text.upper() # HELLO
# 将给定字符串中的所有字母变为小写
text = 'HELLO'
lower_text = text.lower() # hello
（11）首尾字符判断
# startswith()判断字符串是否以括号内指定的字符开头
text = 'Python'
result = text.startswith('Py') # True
# endswith()判断字符串是否以括号内指定的字符开头
text = 'Python'
result = text.endswith('on') # True
（12）格式化输出
- %输出
print("My name is %s; My age is %d; I'have %.2f$" % (name, age, money))
# %s：字符串，基本都用这个
# %d`：整数
# %f：浮点数 （.2f表示保留两位小数）
# %x：十六进制整数
- formate 输出
print("My name is {name}; My age is {age}".format(name=name, age=age))
- f + {} 输出
print(f"My name is {name}; My age is {age}")
（13）拼接join(常用)
- 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
res = '%'.join('hello') # h%e%l%l%o
res = '|'.join(['Tom', '18', 'play']) # Tom|18|play
（14）替换replace（常用）
- 用新的字符替换字符串中旧的字符
# 语法:replace('旧内容', '新内容') 全部修改
res = 'My age is 18!'
res = res.replace('18', '73')
# 语法:replace('旧内容', '新内容') 修改指定个数
res = 'my name is Tom, my age is 18!'
res = res.replace('my', 'MY', 1)
（15）判断类型 isdigit（）
- 判断字符串是否是纯数字组成，返回结果为True或False
str = '5201314'
res = str.isdigit() # True
str = '123g123'
res = str.isdigit() # False
【3】内置方法(了解)
（1）字符串查找
find从指定范围内查找子字符串的起始索引，从左向右查找，找得到则返回元素所在的索引位置，找不到则返回-1
# 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
str1 = 'Python'
res = str1.find('y', 1, 3) # 1
rfind从指定范围内查找子字符串的起始索引，从右向左查找，找得到则返回元素所在的索引位置，找不到则返回-1
str1 = 'Python'
res = str1.rfind('o') # 4
-
index:同find,但在找不到时会报错 -
rindex:同rfind,但在找不到时会报错 -
count统计指定字符在大字符串中出现的次数
（2）填充
center用指定字符填充指定字符串，如果两侧不平衡，则右多左少
msg = '新系统'
res = msg.center(len(msg) + 6, '-')
-
ljust字符串长度要基于给指定字符长度的基础上增加，填充在原有字符串的右侧 -
rjust字符串长度要基于给指定字符长度的基础上增加，填充在原有字符串的左侧 -
zfill用 0 填充，填充在字符串左侧
（3）制表符（expandtabs）
name = 'Tom\thello' # Tom hello 默认四个字符
location = "Tom\thello"
expanded_name = location.expandtabs(2) # Tom hello
（4）首字母大写(captalize)
- 只会将这一行的第一个单词的首字母大写，其他单词不变
text = 'hello world'
capitalized_text = text.capitalize() # 'Hello world'
（5）大小写翻转(swapcase)
- 大写变小写，小写变大写，进行颠倒
mixed_case = 'HeLLo WoRLd'
swapped_case = mixed_case.swapcase()
print(swapped_case) # 'hEllO wOrlD'
（6）单词首字母大写(title)
- 将给定句子的每一个单词的首字母大写
sentence = 'hello python, nice'
title_case = sentence.title()
print(title_case) # 'Hello Python, Nice'
【4】判断字符串类型
name = 'Hello123'
print(name.isalnum()) # 字符串中既可以包含数字也可以包含字母，True
print(name.isalpha()) # 字符串中只包含字母，False
print(name.isidentifier()) # 字符串是否是合法标识符，True
print(name.islower()) # 字符串是否是纯小写，True
print(name.isupper()) # 字符串是否是纯大写，False
print(name.isspace()) # 字符串是否全是空格，False
print(name.istitle()) # 字符串中的单词首字母是否都是大写，False
【四】列表类型(list)
【1】定义
- 列表可以包含多个元素，每个元素之间用逗号
,隔开，并用方括号[]括起来。
mixed_list = [1, 'two', 3.0, 'four', 5]
【2】内置方法(学会)（类比于字符串）
（1）类型强转
- 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型
# 示例
string1 = 'hello'
list1 = list(string1) # ['h', 'e', 'l', 'l', 'o']
tuple1 = (1, 2, 3)
list1 = list(tuple1) # [1, 2, 3]
range1 = range(4)
list1 = list(range1) # [1, 2, 3]
（2）按索引存取值（可取值，可修改）
numbers = [1, 2, 3, 4, 5]
first_number = numbers[0]
last_number = numbers[-1]
index_10 = numbers[10] #超出范围会报错
（3）切片
numbers = [1, 2, 3, 4, 5]
sliced_numbers = numbers[1:4] # [2, 3, 4]
stepped_numbers = numbers[0:4:2] # [1, 3]
（4）计算长度
numbers = [1, 2, 3, 4, 5]
length = len(numbers) # 5
（5）成员运算
numbers = [1, 2, 3, 4, 5]
3 in numbers
6 not in numbers
（6）增加
append默认追加到末尾（不管是什么类型的数据，都会当成一个整体元素填进去）
numbers = [1, 2, 3, 4, 5]
numbers.append([6,7]) # [1, 2, 3, 4, 5, [6, 7]]
extend一次性在列表尾部添加多个元素、合并列表
numbers = [1, 2, 3, 4, 5]
numbers.extend([6,7]) # [1, 2, 3, 4, 5, 6, 7, 8]
insert在指定位置添加元素（索引位置，不管是什么类型的数据，都会当成一个整体元素填进去）
numbers = [1, 2, 3, 4, 5]
numbers.insert(0, [0, 0.5]) # [[0, 0.5], 1, 2, 3, 4, 5]
（7）删除
del删除指定索引的元素
numbers = [1, 2, 3, 4, 5]
del numbers[0] # [2, 3, 4, 5]
pop默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
numbers = [1, 2, 3, 4, 5]
pop_num = numbers.pop(0)
print(pop_num) # 1
print(numbers) # [2, 3, 4, 5]
remove括号内指名道姓表示要删除哪个元素，没有返回值
numbers = [1, 2, 3, 4, 5]
numbers.remove(2) # [1, 3, 4, 5]
（8）颠倒元素(reverse())
numbers = [1, 2, 3, 4, 5]
numbers.reverse() # [5, 4, 3, 2, 1]
（9）元素排序
sort()方法用于对列表进行排序，默认是升序排序。- 如果你需要保留原列表，可以使用
sorted()函数 - 可以按照自定义排序规则排序
numbers = [5, 2, 3, 1, 4]
numbers.sort() # [1, 2, 3, 4, 5] reverse默认值为False
numbers.sort(reverse=True) # [5, 4, 3, 2, 1]
# 按照绝对值排序
numbers = [5, -2, 3, 1, -4]
numbers.sort(key=abs) # [1, -2, 3, -4, 5]
# 保留原列表
numbers = [5, 2, 3, 1, 4]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # 输出: [1, 2, 3, 4, 5]
print(numbers) # 输出: [5, 2, 3, 1, 4]
（10）遍历循环 （常用enumerate）
# for循环遍历列表
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
print(fruit)
# while循环遍历列表
fruits = ['apple', 'banana', 'orange']
index = 0
while index < len(fruits):
print(fruits[index])
index += 1
- 遍历时获取索引 enumerate()
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
print(f"Index: {index}, Fruit: {fruit}")
# Index: 0, Fruit: apple
# Index: 1, Fruit: banana
# Index: 2, Fruit: orange
（11）步长操作
numbers = [1, 2, 3, 4, 5]
result = numbers[::2] # [1, 3, 5]
result = numbers[::-2] # [5, 3, 1]
result = numbers[::-1] # 列表反转
（12）字符串排序比较
- 原理：依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素
# 对列表中的数字进行排序
l1 = [1, 2, 3]
l2 = [1, 3，2]
l2 > l1 # 第二位3的ASCII码大于2的ASCII码
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1 = 'abc'
s2 = 'az'
s2 > s1 # 第二位z的ASCII码大于b的ASCII码
# 所以我们也可以对下面这个列表排序
l = ['A', 'z', 'adjk', 'hello', 'hea']
l.sort()
print(l) # ['A', 'adjk', 'hea', 'hello', 'z'] 大写字母的ASCII码大于小写字母的ASCII码
【五】元组类型(tuple)
【1】元组类型定义
-
元组（Tuple）是Python中的一种有序、不可变的数据类型。
-
元组使用小括号（）来定义，可以包含任意类型的元素，包括数字、字符串、列表等。
-
在Python中，可以使用逗号
,来创建元组，通常也建议使用小括号，尽管小括号并不是必须的。例如：
tuple1 = 1, 2, 3
tuple2 = (1, 2, 3)
tuple1 = (1,)
tuple1 = (1) #这不是元组而是整数1，单个元素末尾后面需要添加，
【2】内置方法
（1）类型强转
- 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
- 使用
tuple()函数可以将其他可迭代对象转换为元组
numbers = [1, 2, 3, 4, 5]
tuple1 = tuple(numbers)
（2）索引取值（类比于字符串）（不能修改）
fruit_tuple = ('apple', 'banana', 'cherry')
fruit_tuple[0] # apple
fruit_tuple[-1] # cherry
fruit_tuple[-1] = "pear" # 报错
（3）切片(顾头不顾尾)
- 和字符串、列表一样
（4）计算长度
- 使用
len()函数可以获取元组的长度 - 和字符串、列表一样
（5）成员运算
- 与字符串列表相同，元组也支持
in和not in运算符
（6）遍历循环
- 和字符串、列表一样
（7）元组拼接
- 使用
+运算符可以将两个元组拼接成一个新的元组 - 和字符串、列表一样
（8）元组重复
- 使用
*运算符可以将元组重复指定次数 - 和字符串、列表一样
【六】布尔类型(bool)
-
True：非零数字、非空字符串、非空列表、非空字典、非空集合等
-
False：零数字、空字符串、空列表、空字典、空集合等
【七】字典类型(dict)
【1】字典类型定义
- 字典（Dictionary）是一种无序的数据集合，使用键（key）和值（value）之间的映射关系来存储数据。
- 字典是Python中唯一的映射类型，其它语言中可能称为关联数组或哈希表。
- 字典的特点：
- 字典中的数据是无序的，不能通过索引来访问，而是通过键来访问。
- 字典中的键必须是不可变的，通常使用字符串、数字或元组作为键。
- 字典中的值可以是任意类型，包括数字、字符串、列表、字典等。
- 字典的创建使用花括号
{}，并使用冒号:分隔键和值。 - 多个键值对之间使用逗号
,分隔。
person_info = {'name': 'Tom', 'age': 25, 'gender': 'male'}
【3】内置方法
（1）取值
- 使用中括号加键名（超出范围会报错）
person_info = {'name': 'Tom', 'age': 25}
person_info['name'] # Tom
person_info['name1'] # 报错
get，如果键不存在，则返回指定的默认值（默认为None）（不会报错）
person_info = {'name': 'Tom', 'age': 25}
person_info.get('name') # Tom
person_info.get('height', 180) # 175
（2）计算长度
- 使用
len函数可以计算字典中键值对的个数
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
len(person_info) # 3
（3）成员运算
- 使用
in和not in可以判断一个键是否存在于字典中
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
'name' in person_info # True
'height' not in person_info # True
（4）增加
# 直接添加
person_info = {'name': 'Tom', 'age': 25}
person_info['height'] = 180 # 'name': 'Tom', 'age': 25, 'height': '180'
# update方，可以批量新增键值对，如果键已经存在，则更新对应的值
person_info = {'name': 'Tom', 'age': 25}
person_info.update({'height': 180, 'weight': 60}) # 'name': 'Tom', 'age': 25, 'height': '180', 'weight': 60
# setdefault(key, default) 和update相比多了返回值，返回default
person_info = {'name': 'Tom', 'age': 25}
height = person_info.setdefault('height', '180') # height = 180
（5）删除
# del键
person_info = {'name': 'Tom', 'age': 25}
del person_info['age'] # 'name': 'Tom'
# pop键值，比del多返回键所对应的值
person_info = {'name': 'Tom', 'age': 25}
age = person_info.pop('age') # age = 25
# clear 清空字典
person_info = {'name': 'Tom', 'age': 25}
person_info.clear() #
# popitem 随机删除键值对（由于字典无序），以元组的形式返回被删除的键值对，python3.7+版本是删除最后一个值
person_info = {'name': 'Tom', 'age': 25}
popitem1 = person_info.popitem() # 随机可能（'name': 'Tom'）
（6）获取键值对
- 返回的都是可迭代对象
# keys，获取字典中所有的键，返回一个可迭代的视图对象
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
keys = person_info.keys() # dict_keys(['name', 'age', 'height'])
# values，获取字典中所有的值，返回一个可迭代的视图对象
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
values = person_info.values() # dict_values(['Tom', '25', '180'])
# items，获取字典中所有的键值对，返回一个可迭代的视图对象
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
items = person_info.items() # dict_items([('name', 'Tom'), ('age', 25), ('height', '180')])
（7）遍历循环
- 使用较多的是items
# 只遍历key
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
for key in person_info:
pass
# 只遍历values
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
for values in person_info.values():
pass
# 遍历key和value
person_info = {'name': 'Tom', 'age': 25, 'height': '180'}
for key, values in person_info.items():
pass
（8）字典排序(sorted())
- 字典的排序是通过字典的键来进行的，使用
sorted()函数可以对字典进行排序。 - 可以按照自定义要求排序
my_dict = {'apple': 3, 'banana': 2, 'orange': 1}
# 默认，对字典按键排序，并返回一个列表
sorted1 = sorted(my_dict) # ['apple', 'banana', 'grape', 'orange']
sorted1 = sorted(my_dict.items()) # [('apple', 3), ('banana', 2), ('orange', 1)]
# 按照特定要，这个就是按照值来排序
sorted1 = sorted(my_dict.items()，key=lambda x: x[1]) # [('orange', 1), ('banana', 2), ('apple', 3)]
- 在这个示例中，
key参数指定了按值排序，并使用了lambda函数提取元组中的第二个元素（值）作为排序的关键字。
【八】集合类型(set)
【1】集合类型定义
- 集合（Set）是 Python 中的一种无序且不重复的数据类型。
- 集合类型的定义使用大括号
{}，元素之间使用逗号,分隔。
a = {1, 2, 3, 4, 5} # {1, 2, 3, 4, 5}
b = {'T', 'o', 'm'} # 可能{'m', 'T', '0'}
c = {1,2,2,3,3} # {1, 2, 3}
【2】内置方法
（1）类型强转(可以去重)
- 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
# 字符串—>集合
str1 = 'Tom'
set1 = set(str1) # {'m', 'T', 'o'}
# 字典键—>集合
my_dict = {'apple': 3, 'apple': 2, 'orange': 1}
set1 = set(my_dict) # {'orange', 'apple'}
# 字典值—>集合
my_dict = {'apple': 1, 'banana': 2, 'orange': 1}
set1 = set(my_dict.values()) # {1, 2}
# 列表—>集合
my_list = [1, 2, 2]
set1 = set(my_list) # {1, 2}
# 元组—>集合
my_tuple = (1, 2, 2)
set1 = set(my_tuple) # {1, 2}
# 单个元素不可以，比如布尔、整数、浮点数
set(100) # 报错
（2）添加元素
# add，添加单个元素
my_set = {1, 2, 3}
my_set.add(4)
# update，添加多个元素,参数是一个可迭代对象。
my_set = {1, 2, 3}
my_set.add([4, 5]) # {1, 2, 3, 4, 5}
（3）删除元素
# remove,删除指定元素，没有回报错
my_set = {1, 2, 3}
my_set.remove(4) # 报错
# discard,删除指定元素，没有回报错
my_set = {1, 2, 3}
my_set.discard(4) # 不会报错
# pop，伪随机（根据HashMap删除第一个元素）（存在字符串时，每次HashMap可能都不一样），集合为空会报错
my_set = {1, 2}
my_set.pop() # {2}
my_set.pop() # {}
my_set.pop() # 报错
（4）集合简单操作
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# union 并集
union_set = set1.union(set2) # {1, 2, 3, 4, 5}
# intersection 交集
intersection_set = set1.intersection(set2) # {3}
# difference 差集
difference_set = set1.difference(set2) # {1, 2}
# symmetric_difference 对称差集
symmetric_difference_set = set1.symmetric_difference(set2) # {1, 2, 4, 5}
# issuperset 父集
set1 = {1, 2, 3}
set2 = {2, 3}
is_superset = set1.issuperset(set2) # True
# issubset 子集
set1 = {1, 2, 3}
set2 = {2, 3}
is_subset = set2.issubset(set1) # True
# 集合内容是否相等
set1 = {1, 2}
set2 = {2, 1}
set1 == set2 # True
（5）计算长度 len
set1 = {1, 2, 3}
len(set1) # 3
（6）遍历循环 for
set1 = {1, 2, 3}
for n in set1:
pass
（7）成员运算
set1 = {1, 2, 3}
# in
flag = 1 in set1 # True
# not in
flag = 4 not in set1 # True
【八】数据类型总结
| 按存值个数区分 | |
|---|---|
| 只能存一个值：可称为标量/原子类型 | 数字类型、字符串、布尔类型 |
| 可以存放多个值：可称为容器类型 | 列表、元祖、字典 |
| 按照访问方式区分 | |
|---|---|
| 直接访问：只能通过变量名访问整个值 | 数字类型、布尔类型 |
| 顺序访问：可以通过索引访问指定的值，索引代表顺序，又称为序列类型 | 字符串、列表、元祖 |
| key访问：可以用key访问指定的值，又称为映射类型 | 字典 |
| 按可变不可变区分 | |
|---|---|
| 可变类型 | 列表、字典 |
| 不可变类型 | 数字、字符串、元祖、布尔 |