天池龙珠计划-python训练营-Task2-python基础（数据结构）
文章目录
前言
- 主要特点
- 二、元组
-
- 1、创建与访问操作
-
- 2、元组的更新与修改操作
-
- 3、元组运算符
-
- 4、内置函数方法
-
-
5、展平元组结构
-
三、字符串
-
- 1、转义字符
- 2、字符串的切片与拼接
- 3、内置方法
- 4、字符串格式化
-
四、字典
-
- 1、可变类型与不可变类型
- 2、创建与访问
- 3、内置方法
-
五、集合
-
- 1、创建
- 2、访问
- 3、内置方法
- 4、 不可变集合
-
序列 （通用）
-
总结
-
前言
天池龙珠计划-python训练营-Task2 python基础：
系统性地教授python的列表（list）、元组（tuple）、字符串（str）、字典（dict）、集合（set）以及序列的相关知识。
涵盖创建对象的方式以及对其属性进行更新和访问的方法。
一、列表
1、特点：
有序；无固定大小；同一列表内数据类型不唯一；
mix = [1, 'lsgo', 3.14, [1, 2, 3]]2、常用创建方法
mix = [1, 'lsgo', 3.14, [1, 2, 3]] #直接赋值
x = list(range(1, 11, 2)) #list进行数据类型转换
x = [i for i in range(10)] #推导式
x = [] #可以为空因为列表中的每个元素都可以是任意类型的对象，在存储的时候系统会将每个对象的信息通过内存地址的形式记录下来。例如以一个简单的[1,2,3]为例，在这个例子中系统会存储三个内存地址（指针）以及三个整数值对象。
x = [[0] * 3]
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>在x = [a] * 4的操作过程中，在生成四个指向列表的引用时，在当a发生变化时，在x中的四个引用也会随之变化。
3、列表可更改
由于列表是可变的（mutable），附加（append, extend）、插入（insert）、删除（remove, pop）等操作均可执行。
#注意参数区别，一个是obj，一个是seq（序列）③将对象obj插入到指定索引位置的位置进行插入操作。
④该函数用于消除列表中的第一个匹配项。
⑤若无需再访问被删除的元素，请直接执行del语句；若希望在后续操作中仍能访问该元素，则应调用pop()函数。
4、获取
①利用元素的索引值来从列表中取出单一元素，请注意这些索引值都是从0开始计算的。
②当指定索引为-1时会返回列表末尾的那个元素；若指定-2则会得到倒数第二个元素依此类推。
③切片操作采用start:stop:step格式
索引展示：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
0 1 2 3 4
-5 -4 -3 -2 -1切片
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:]) # ['Thursday', 'Friday']
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
print(week[1:4:2]) # ['Tuesday', 'Thursday']
print(week[:4:2]) # ['Monday', 'Wednesday']从上述实例中可以看出，在切片操作中索引的位置设置遵循特定规则：其中索引的位置包括start而不包括stop的位置
5、数组拷贝
list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]差别在于修改原列表后，复制的列表是否发生改变
6、列表操作符
「双等号运算符」只有当元素及其位置同时满足时才返回True。
「加法连接运算符」用于将两个列表拼接成一个新列表。
「乘法连接运算符」用于将一个列表按倍数复制并拼接成新列表。
「成员归属关系判断运算符」包括「in」和「not in」两种类型，在特定条件下判断元素是否存在。
列表拼接有两种方式：使用「加法连接运算符 +」实现首尾拼接效果；而使用「乘法连接运算符 *」则可实现按倍数复制效果。
7、其他方法
① list.count(obj) 计算该元素在列表中的出现频率
② list.index(x[, start[, end]]) 返回该值首次出现时所对应的索引位置
③ list.reverse() 反转该列表中的所有元素顺序
④ list.sort(key=None, reverse=False) 按照指定的关键字对原始数据进行排序
- key – 键的主要作用是用于比较，在函数中仅接受一个参数；该参数来源于可迭代对象中的单个元素，并用于排序操作。
- reversed – 它们定义了排序方式：当reversed=True时执行降序排列；当reversed=False时执行升序排列（默认情况下为升序）。
- 此方法本身不返回任何结果，但会将列表对象进行排序操作。
二、元组
「元组」定义语法为：(元素1, 元素2, …, 元素n)
- 小括号把所有元素绑在一起
- 逗号将每个元素一一分开
1、创建与访问
Python中的元组与列表具有相似性，在功能上tuple一旦创建就无法对其进行修改类似于字符串的对象。
通常会使用圆括号表示元组对象而方括号则用于表示列表对象。
此外，在结构上元组和列表也有许多相似之处它们同样支持通过整数索引和切片操作来进行数据访问和操作。
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python') <class 'tuple'>
print(t2, type(t2))
# (1, 10.31, 'python') <class 'tuple'>
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1]) # 2
print(tuple1[5:]) # (6, 7, 8)
print(tuple1[:5]) # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)如果元组仅有一个元素，则在该元素后应添加逗号以避免括号被误解为运算符。
二维元组
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python2、元组的更新与修改
不能修改元组，但是对于元组中的元素，如果是可以修改的，就可以
week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')l
list 的内容是可以修改的
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
3、元组操作符
对于等价于（==）运算来说，在对象完全一致的情况下才会返回True。
元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
4、内置操作方法
元组大小和内容都不可更改，因此只有 count 和 index 两种方法。
5、解压元组
相当于将元组中的元素赋值给自定义变量
#【例子】解压（unpack）一维元组（有几个元素左边括号定义几个变量）
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python
#【例子】解压二维元组（按照元组里的元组结构来定义变量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python
#【例子】如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。
#下例就是把多个元素丢给了 rest 变量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
#【例子】如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b) # 1 2三、字符串
1、转义字符
2、字符串的切片与拼接
- 持续遵循不可变性的特性
- 起始于位置0（如同Java）
- 切片通常以start:end的形式呈现，在这种表示法中包含「start 索引」对应的元素而不包含「end 索引」对应的元素。
- 索引值支持正数或负数表示位置，在这种表示法中：
- 正数值将从左到右依次计数，默认起始位置为0
- 负数值将从右到左依次计数，默认起始位置为-1
- 使用负数索引时会以最后一个元素为基准进行计算
3、内置方法
capitalize() 将字符串的第一个字符转换为大写。
lower() 转换字符串中所有大写字符为小写。
upper() 转换字符串中的小写字母为大写。
swapcase() 将字符串中大写转换为小写，小写转换为大写。
该函数用于统计字符串中特定子字符串的出现次数，默认从索引0开始计算，并覆盖整个字符串。当指定beg或end参数时，则仅统计该区间内的出现次数。
str2 = "DAXIExiaoxie"
print(str2.count('xi')) # 2- 使用endswith()方法判断一个字符串末尾是否有特定的子串suffix（默认从位置0开始），如果没有匹配到则返回False；如果指定了begin和end参数，则该方法将仅在该区间内进行匹配。
- 借助startswith()函数来判断一个字符串的起始位置是否带有特定的子串substr（默认从位置0开始），如果存在则返回True；若指定了begin和end参数，则该函数将在该设定区域内进行匹配。
str2 = "DAXIExiaoxie"
print(str2.endswith('ie')) # True
print(str2.endswith('xi')) # False
print(str2.startswith('Da')) # False
print(str2.startswith('DA')) # True- isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。
str3 = '12345'
print(str3.isnumeric()) # True
str3 += 'a'
print(str3.isnumeric()) # False*ljust(width[, fillchar]) 返回一个原字符串左对齐，并以fillchar（默认空格）填充至宽度的新字符序列。
*rjust(width[, fillchar]) 返回一个原字符串右对齐，并以fillchar（默认空格）填充至宽度的新字符序列。
str4 = '1101'
print(str4.ljust(8, '0')) # 11010000
print(str4.rjust(8, '0')) # 00001101- 删除多余的部分并保留必要的内容。
- 去除前部多余的空白或其他指定内容。
- 分别对前后两端进行删减以达到干净整洁的效果。
str5 = ' I Love LsgoGroup '
print(str5.lstrip()) # 'I Love LsgoGroup '
print(str5.lstrip().strip('I')) # ' Love LsgoGroup '
print(str5.rstrip()) # ' I Love LsgoGroup'
print(str5.strip()) # 'I Love LsgoGroup'
print(str5.strip().strip('p')) # 'I Love LsgoGrou'- partition(sub)识别子字符串sub并将其分割为三元组(pre_sub, sub, fol_sub)，若未找到则返回(‘原字符串’,’’,’’)。
- rpartition(sub)如同partition()方法一样地工作但rpartition(sub)是从右端执行的。
str5 = ' I Love LsgoGroup '
print(str5.strip().partition('o')) # ('I L', 'o', 've LsgoGroup')
print(str5.strip().partition('m')) # ('I Love LsgoGroup', '', '')
print(str5.strip().rpartition('o')) # ('I Love LsgoGr', 'o', 'up')- replace(old, new [, max]) 将会将字符串中的old替换为new；如果max指定，则仅进行不超过max次的替换操作。
str5 = ' I Love LsgoGroup '
print(str5.strip().replace('I', 'We')) # We Love LsgoGroupsplit(str="", num) 该函数用于将字符串按空格切片，默认情况下分割成多个子字符串。
如果不指定num参数，则仅分割指定数量的子字符串。
该函数返回的是被分割后的子字符串拼接而成的列表。
str5 = ' I Love LsgoGroup '
print(str5.strip().split()) # ['I', 'Love', 'LsgoGroup']
print(str5.strip().split('o')) # ['I L', 've Lsg', 'Gr', 'up']该函数将输入字符串按照指定的分隔符（如\r、\r\n或\n）进行分割，并根据参数keepends的设置决定是否包含末尾换行符。当keepends设为False时，默认情况下不会保留换行符；若设为True，则会保留换行符并生成一个包含每一行内容的列表。
str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines()) # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True)) # ['I \n', ' Love \n', ' LsgoGroup']- maketrans(intab, outtab) 生成字符映射转换表
- translate(table, deletechars="") 基于参数table指定的内容进行字符串转换
str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(trantab) # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
print(str7.translate(trantab)) # th3s 3s str3ng 2x1mpl2....w4w!!!4、字符串格式化
format 格式化函数
str8 = "{0} Love {1}".format('I', 'Lsgogroup') # 位置参数
print(str8) # I Love Lsgogroup
str8 = "{a} Love {b}".format(a='I', b='Lsgogroup') # 关键字参数
print(str8) # I Love Lsgogroup
str8 = "{0} Love {b}".format('I', b='Lsgogroup') # 位置参数要在关键字参数之前
print(str8) # I Love Lsgogroup
str8 = '{0:.2f}{1}'.format(27.658, 'GB') # 保留小数点后两位
print(str8) # 27.66GB
print('%c' % 97) # a
print('%c %c %c' % (97, 98, 99)) # a b c
print('%d + %d = %d' % (4, 5, 9)) # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁!
print('%o' % 10) # 12
print('%x' % 10) # a
print('%X' % 10) # A
print('%f' % 27.658) # 27.658000
print('%e' % 27.658) # 2.765800e+01
print('%E' % 27.658) # 2.765800E+01
print('%g' % 27.658) # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text) # I said: I am 22 years old..
print("I said: %r." % text) # I said: 'I am 22 years old.'
print('%5.1f' % 27.658) # ' 27.7'
print('%.2e' % 27.658) # 2.77e+01
print('%10d' % 10) # ' 10'
print('%-10d' % 10) # '10 '
print('%+d' % 10) # +10
print('%#o' % 10) # 0o12
print('%#x' % 108) # 0x6c
print('%010d' % 5) # 0000000005四、字典
字典中的键:值对是无序的，并且其中每个键都是唯一的，在同一个字典中。
-
dict 的存储结构中对顺序的要求与 key 的插入顺序无关紧要。
-
dict 的查找与插入操作非常快速，并且其性能不会因 key 数量的增长而受限；然而，在实现过程中需要考虑占据大量内存空间。
-
核心要素包括「大括号 {}」、「分隔符 ,」以及「分隔标志 :'。
- 大括号用于组织在一起的所有元素。
- 分隔符的作用是分割成独立的部分。
- 分隔标志则用于区分键与值之间的关系。
1、可变类型与不可变类型
- 序列基于连续整数类作为索引，在此与之相异的是字典采用关键字作为索引键。这些关键字通常是不可变类型，在多数情况下会选用字符串或数值类型。
- 在Python中，字典被视为唯一的映射数据结构；而字符串、元组以及列表则被归类于序列类型。
快速判定一个数据类型 X 是否为可变类型
繁杂方法：调用该函数id(X)，执行特定操作对比前后结果；若两次调用得到的不同标识符值，则说明该数据类型不可变；反之亦然。简便方法：调用hash(X)，只要运行正常即可判定其是否能被哈希化；若成功则说明X是不可变的；若失败则表明X是可变类型的。
2、创建与访问
①赋值
dic1 = {1: 'one', 2: 'two', 3: 'three'}
print(dic1) # {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1]) # onekey值必须存在，且不能越界
②使用Python内置的dict函数构造字典对象，在此过程中确保键值对中的键不可重复赋值而值可自由选择。
③该字典基于映射对象初始化为键值对（key-value）形式。
dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1) # {'cherry': 4098, 'apple': 4139, 'peach': 4127}
dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2) # {'peach': 4127, 'cherry': 4098, 'apple': 4139}a dictionary is created as a new dictionary using keyword arguments. This means that dict(**kwargs) is equivalent to creating a new dictionary initialized with name-value pairs from the keyword arguments provided. For instance, a dictionary can be constructed with key-value pairs such as one=1 and two=2.
在这种情况下，在这种情况下
dic = dict(name='Tom', age=10)
print(dic) # {'name': 'Tom', 'age': 10}
print(type(dic)) # <class 'dict'>3、内置方法
Python中的函数 dict.fromkeys(seq[, value]) 用于生成一个新的字典，在该字典中将序列 seq 的所有元素作为键，并赋予每个键对应的初始值
seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq)
print(dic1)
# {'name': None, 'age': None, 'sex': None}
dic2 = dict.fromkeys(seq, 10)
print(dic2)
# {'name': 10, 'age': 10, 'sex': 10}
dic3 = dict.fromkeys(seq, ('小马', '8', '男'))
print(dic3)
# {'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}② dict.keys() 返回的是一个可迭代的对象；可以通过调用 list() 方法将其转化为一个具体的列表；该列表包含了字典中所有的键值对中的键部分。
③ dict.values() 返回的是一个迭代器对象；若需获取其中的具体数值，则需将其转化为列表；此过程中所获得的结果即为字典中对应的所有数值集合。
④ dict.items() 会以一种包含元组形式的数据结构的方式进行输出；这种数据结构是一个可遍历的对象；每个元组内部包含的是原始字典中对应的键值对。
#key
dic = {'Name': 'lsgogroup', 'Age': 7}
print(dic.keys()) # dict_keys(['Name', 'Age'])
lst = list(dic.keys()) # 转换为列表
print(lst) # ['Name', 'Age']
#value
dic = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print(dic.values())
# dict_values(['female', 7, 'Zara'])
print(list(dic.values()))
# [7, 'female', 'Zara']
#item
dic = {'Name': 'Lsgogroup', 'Age': 7}
print(dic.items())
# dict_items([('Name', 'Lsgogroup'), ('Age', 7)])
print(tuple(dic.items()))
# (('Name', 'Lsgogroup'), ('Age', 7))
print(list(dic.items()))
# [('Name', 'Lsgogroup'), ('Age', 7)]dict.get(key, default=None) 用于获取对应键的值；当该键不在指定字典中时，则返回指定默认值。
dic = {'Name': 'Lsgogroup', 'Age': 27}
print("Age 值为 : %s" % dic.get('Age')) # Age 值为 : 27
print("Sex 值为 : %s" % dic.get('Sex', "NA")) # Sex 值为 : NA
print(dic) # {'Name': 'Lsgogroup', 'Age': 27}dict.default_factory(key, default=None)与get()方法功能类似, 当键不在字典中时,会自动创建该键并将该键映射到指定的默认值
dic = {'Name': 'Lsgogroup', 'Age': 7}
print("Age 键的值为 : %s" % dic.setdefault('Age', None)) # Age 键的值为 : 7
print("Sex 键的值为 : %s" % dic.setdefault('Sex', None)) # Sex 键的值为 : None
print(dic)
# {'Age': 7, 'Name': 'Lsgogroup', 'Sex': None}使用 key 在 dict 中的操作符来判断键是否存在于字典中。若 key 存在于字典 dict 中则返回 true；否则则返回 false。反之，则由 not in 操作符来实现同样的功能。
dic = {'Name': 'Lsgogroup', 'Age': 7}
# in 检测键 Age 是否存在
if 'Age' in dic:
print("键 Age 存在")
else:
print("键 Age 不存在")
# 检测键 Sex 是否存在
if 'Sex' in dic:
print("键 Sex 存在")
else:
print("键 Sex 不存在")
# not in 检测键 Age 是否存在
if 'Age' not in dic:
print("键 Age 不存在")
else:
print("键 Age 存在")
# 键 Age 存在
# 键 Sex 不存在
# 键 Age 存在dict.pop(key,default=None)用于从字典中移除指定键 key 对应的值，并将该值返回（若有默认值则返回默认）。此操作需预先提供 key 参数。
若无该键存在，则会根据是否有指定默认参数而决定返回结果；
del dict[key] 则是用于直接从字典中移除指定键 key 对应的值。
⑨ dict.popitem()会非确定性地移除并返回一个键值对；若字典已空则会导致KeyError异常。
⑩ dict.clear()用于清除全部数据项。
- 使用清除操作将移除字典中的所有键值对。
- 该方法将生成一个与原字典结构相似但不共享数据的新对象。
- 更新操作将整合dict2中的键值对到现有字典中。
dic1 = {'user': 'lsgogroup', 'num': [1, 2, 3]}
# 引用对象
dic2 = dic1
# 浅拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic3 = dic1.copy()
print(id(dic1)) # 148635574728
print(id(dic2)) # 148635574728
print(id(dic3)) # 148635574344
# 修改 data 数据
dic1['user'] = 'root'
dic1['num'].remove(1)
# 输出结果
print(dic1) # {'user': 'root', 'num': [2, 3]}
print(dic2) # {'user': 'root', 'num': [2, 3]}
print(dic3) # {'user': 'runoob', 'num': [2, 3]}五、集合
Python中的set与dict在功能上有相似之处，并且都可以视为一种键值对的集合体。然而，在set中并不存储 associated values（值），因此每个键都是唯一的。
无序性与唯一性
由于 set 基于无序数据结构实现, 因此无法对其建立索引并执行切片操作, 此外该数据结构不具备用于获取元素值的键属性, 但可验证某元素是否属于该集合
1、创建
- 在初始化空集合时必须使用s = set()而非s = {}。
- 为了明确表示数据结构为集合类型，请采用{}的形式。
- 通过调用set(value)函数可将列表或元组转换为对应的集合。
2、访问
- 内置函数用于获取集合长度。
- 通过for循环逐个读取数据。
- 利用in或not in来检测元素是否存在。
3、内置方法
- 集合
set.add(elmnt)实现了向集合中添加元素的功能，在现有元素存在的条件下不会进行任何操作。 - 集合
set.update(set)实现了对现有集合进行更新的功能，在新增数据时会去重处理。 - 集合
set.remove(item)实现了从现有集合中删除指定元素的功能，在无法找到目标数据时会导致异常。 - 集合
set.discard(value)实现了删除指定数据项的功能，在目标数据不存在的情况下不会引发异常。 - 集合
set.pop()实现了从现有数据中随机获取一个值的功能。
由于 set 是无序和无重复元素的集合, 所以两个或多个 set 可以做数学意义上的集合操作.
因为 set 是一种非有序且不包含重复元素的数据结构, 在数学运算中集合操作可以通过其实现.
set.intersection(set1, set2) 返回两个集合的交集。
set1 & set2 返回两个集合的交集。
set intersection update is a method that modifies the set by removing elements not present in another set.
set.union(set1, set2) 返回两个集合的并集。
set1 | set2 返回两个集合的并集。
set.difference(set) 返回集合的差集。
set1 - set2 返回集合的差集。
Python中的set类有一个difference_update方法（set_differencemethod），用于执行两个集合之间差集运算（A - B），其功能是删除指定集合中的元素（B），而不会返回任何值。
set.symmetric_difference(set)返回集合的异或。
set1 ^ set2 返回集合的异或。
该方法用于从一个给定的set对象中删除与另一个指定set对象重叠的部分，并将其不在该current set中的不同部分添加进来。
使用set.issubset(set)判定一个集合是否被其他集合所包含。如果满足条件则返回True；否则返回False。
使用<=运算符比较两个集合的关系
该方法用作判定一个集合是否包含另一个集合，在这种情况下会返回 True，在其他情况下则返回 False。
判断一个集合是否包含另一个集合？如果是则返回True否则返回False
set.isdisjoint() 被用来判断两个集合是否有共同元素；如果无共同元素，则会返回True。
4、 不可变集合
Python提供了不可变元素的集合实现版本,即不允许修改其元素数量,其类型名为frozenset.值得注意的是,在这种情况下仍可执行集合操作,但无法使用带有update的方法.
a = frozenset(range(10)) # 生成一个新的不可变集合
print(a)
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset('lsgogroup')
print(b)
# frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})序列 （通用）
在 Python 中涉及的数据结构涵盖了字符串、列表、元组以及特殊的集合与字典。
这些数据结构能够执行一系列普遍的操作。
它们（指集合与字典）不具备索引运算、切片操作以及相加相乘的功能。
1、强制类型转化
- The list constructor takes a iterable object as an argument and returns it as a list.
- The tuple constructor takes a iterable object as an argument and returns it as a tuple.
- The string representation of the object is returned by the str function.
2、统计方法
len(s) 返回对象（字符、列表、元组等）长度或元素个数。
max(sub)返回序列或者参数集合中的最大值
min(sub)返回序列或参数集合中的最小值
sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和
该函数用于对可迭代对象进行排序操作。
iterable参数指定需要排序的可迭代对象。
key参数用于指定比较标准或规则。
reverse参数决定升序还是降序排列（默认为升序）。
返回重新排序后的列表。
该函数生成一个反向迭代器。
其中seq – 包含要转换为反向序列的对象。
s = 'lsgogroup'
x = reversed(s)
print(type(x)) # <class 'reversed'>
print(x) # <reversed object at 0x000002507E8EC2C8>
print(list(x))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p')
print(list(reversed(t)))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
r = range(5, 9)
print(list(reversed(r)))
# [8, 7, 6, 5]
x = [-8, 99, 3, 7, 83]
print(list(reversed(x)))
# [83, 7, 3, 99, -8]该函数用于对sequence进行索引枚举，并指定起始索引值为0。它会将可遍历的对象组合成一个索引序列，在for循环中通常会用到这个操作。该方法特别适用于需要同步跟踪数据与其下标的情况。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
b = list(enumerate(seasons, 1))
print(b)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
for i, element in a:
print('{0},{1}'.format(i, element))
# 0,Spring
# 1,Summer
# 2,Fall
# 3,Winterzip(iter1[, iter2, ...])
该函数用于接受多个可迭代对象作为参数，并将对应位置上的元素分别打包成元组。生成一个包含这些元组的对象（通常为列表或元组），此方法的优势在于节省了大量内存空间。
通过调用list()函数可以方便地将其转换为列表形式。当各迭代器的元素数量不同时，默认结果长度与最短的那个一致。若需获取完整展开后的结果，则可直接遍历该对象；若需要特定长度的结果，则需结合其他操作进行处理：通过使用星号运算符展开元组元素到多个位置即可实现解压功能。
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)
print(zipped) # <zip object at 0x000000C5D89EDD88>
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
a1, a2 = zip(*zip(a, b))
print(list(a1)) # [1, 2, 3]
print(list(a2)) # [4, 5, 6]总结
基础方法！常用！常用！常用！