more is less.❤
文章目录
一、集合
1、概念
集合是多个元素类型的无序组合
与数学中的集合概念一致
集合元素之间无序，每个元素是唯一的，不存在相同元素
集合元素不可更改
集合元素不能是可变数据类型
2、表示
集合用大括号{}表示，元素之间用逗号 , 分隔
建立集合可以用{}或者set，而如果要建立空集合只能用set()
例如：
A = {'C', "Python", 666} B = set("Python") print(B)#{'h', 'o', 'n', 't', 'y', 'P'}如果建立集合的时候包含了相同元素，那么生成的集合会自动去重
例如：
A = {'C', "Python", 666, "Python"} print(A)#{'C', 666, 'Python'}
3、集合操作符
| 操作符 | 描述 | 数学简称 |
| S | T | 返回S与T的并集 | 并 |
| S & T | 返回S与T的交集 | 交 |
| S - T | 返回在集合S但不在T中的元素的集合（差集） | 差 |
| S ^ T | 返回在集合S或T中，但不同时在集合S和T中的元素的集合（补集） | 补 |
| S <= T 或S < T | 返回True/False，判断S和T的子集关系 | |
| S >= T 或 S > T | 返回True/False，判断S和T的子集关系 |
举个栗子：
A = {'C', "Python", 666}
B = set("C++666")
print(B)#{'6', 'C', '+'}
print(A | B)#{'+', 'C', 'Python', '6', 666}
print(A & B)#{'C'}
print(A - B)#{'Python', 666}
print(A ^ B)#{'6', 'Python', '+', 666}
A = {'C'}
B = set("C")
print(A < B)#False,A不是B的真子集
print(A <= B)#True，A是B的子集
print(A > B)#False,B不是A的真子集
print(A >= B)#True，B是A的子集
4个增强操作符
| 操作符 | 等价于 |
| S | = T | S = S | T |
| S - = T | S = S - T |
| S & = T | S = S & T |
| S ^ = T | S = S ^ T |
4、集合处理方法
| 操作函数或方法 | |
| S.add(x) | 如果x不在S中，将x添加到S中 |
| S.discard(x) | 移除S中的元素x，如果x不在集合中不报错 |
| S.remove(x) | 移除S中的元素x，如果x不在集合中会产生KeyError异常 |
| S.clear() | 清空集合S |
| S.pop() | 随机返回S中的一个元素，取出这个元素，如果为空那么产生KeyError异常 |
| S.copy() | 拷贝集合S |
| len(S) | 返回集合S的元素个数 |
| x in S | 元素x在集合S中，返回True，否则返回False |
| x not in S | 元素x不在集合S中，返回True，否则返回False |
5、应用
包含关系比较
print('p' in {'p', 'y', '123'})#True
数据去重
ls = ['p', 'y', 'p', 'y', ]
ls = set(ls)
print(ls)#{'p', 'y'}
二、序列
1、概念
序列是具有先后关系的一组元素
元素之间存在先后关系，所以元素可以相同
可以通过下标访问序列的特定元素
序列是一种基类数据类型，一般我们使用其衍生出的数据类型
衍生出：字符串类型，元组类型，列表类型
在序列类型中，元素存在正向递增和反向递减序号的索引关系
如图所示
序列中每一个元素可以是任意类型，我们可以通过特定的索引来找到相应的元素
2、表示
因为我们通常使用的是序列的衍生类型
所以表示要视你所使用的类型而定
例如元组是用一对小括号()，而列表是用一对中括号 [ ]
3、操作符
| 操作符及应用 | 描述 |
| x in s | 如果x是序列s中的元素，返回True，否则返回False |
| x not in s | 如果x不是序列s中的元素，返回True，否则返回False |
| s + t | 连接两个序列s和t |
| s*n 或 n*s | 将序列s复制n次 |
| s[i] | 索引，返回s中的第i个元素 |
| s[M:N:K] | 切片，返回s中从M到N以K为步长的子序列 |
4、函数和方法
| 函数和方法 | 描述 |
| len(s) | 返回序列s的长度 |
| min(s) | 返回序列s中最小的元素，若序列元素不可比较则报错 |
| max(s) | 返回序列s中最大的元素，若序列元素不可比较则报错 |
| s.index(x) | 返回序列s中第一次出现x的位置 |
| s.index(x,i,j) | 返回序列s中从i到j第一次出现x的位置 |
| s.count(x) | 返回s中出现x的次数 |
举个栗子：^_^
s = [1, 'fg', "niubi", 3.1415926]
print(len(s))# 4
s = "python"
#序列元素都是字母，故按照字母序来比较
print(max(s))# y
print(min(s))# h
5、几个衍生类型
（1）元组类型
元组是一种序列类型，一旦创建就不能被修改
使用小括号()或tuple来创建，元素之间用逗号分隔
有些时候不用小括号比如函数return几个用逗号分隔的元素就是元组类型
元组类型继承了序列的全部通用操作符和函数
元组可以嵌套，形成类似于多维函数的结构
举个栗子：^_^
animals = ("cat", "panda", "tiger")
print(animals[::-1]) # ('tiger', 'panda', 'cat')
zoo = ("people", 100, animals)
print(zoo[-1][2]) # tiger
记住重点，元组类型的元素一旦创建就不能修改！
（2）列表类型
列表是一种序列类型，创建后可以被随意更改
列表你怕不是没有原则吧哈哈哈~~~~~ ^_^
列表使用一对中括号[ ]或list()函数创建，元素之间用逗号，分隔
元素可以相同，无长度限制
值得注意的是：方括号或list()函数才会真正创建一个列表，赋值只表示引用(我觉得与C++引用概念类似)
举个栗子：^_^
animals = ["cat", "panda", "tiger", 100] zoo = animals print(zoo) #['cat', 'panda', 'tiger', 100]如代码所示，animals赋值给了zoo，但是只不过是这个列表有两个名字而已，
学过C应该知道，相当于一块内存对应两个指针，就酱
列表类型的操作函数和方法就比较多了~
除过继承的序列的方法还有——
函数或方法 描述 ls[i] = x 替换列表中第i个元素为x ls[i:j:k] = lt 用列表lt替换ls切片后所对应的元素子列表 del ls[i] 删除列表ls中第i个元素 del ls[i:j:k] 删除列表ls中从 i 到 j 步长为 k 的元素 ls+=lt 更新列表 ls 把lt加到 lt 中 ls *= n 更新列表ls，使其重复n次 ls.append(x) 在列表最后添加元素x ls.clear() 清空列表ls ls.copy() 生成一个新列表，赋值ls中的所有元素 ls.insert(i,x) 在列表第i个位置增加元素x ls.pop(i) 把列表中第i个位置元素取出并在列表中删除 ls.remove(x) 把列表中第一个出现的元素x删除 ls.reverse() 把列表元素反转 sorted(ls) 对列表ls排序 举个栗子：^_^
animals = ["cat", "panda", "tiger", 100] animals[1:2] = ["dog", "rabbit"] print(animals)# ['cat', 'dog', 'rabbit', 'tiger', 100] del animals[::3]#从起始元素开始以步长为3删，故删掉'cat','tiger' print(animals)#['dog', 'rabbit', 100] animals.append('eleplant') print(animals)# ['dog', 'rabbit', 100, 'eleplant'] animals.insert(3, 'cat')#原第3个位置的元素被顶到后面 print(animals)# ['dog', 'rabbit', 100, 'cat', 'eleplant']
6、应用
数据表示
元组可以用于元素不改变的应用场景，比如函数return 返回值就经常使用元组类型
而列表则更加灵活
不管是元组还是列表，最主要的目的还是要表示一组有序数据，从而进一步操作
for item in ls
数据保护
如果多人协作的程序，不希望别人修改你的数据，那么可以在写接口是规定传递的数据为元组类型
animals = ["cat", "panda", "tiger", 100]
zoo = tuple(animals)
print(zoo)# ('cat', 'panda', 'tiger', 100)
通过tuple()函数我们可以对数据进行保护
三、字典
我觉得和C++的map差不多。。。。嗯
1、概念
首先理解映射：映射就是一种键（索引）和数值（数据）的对应关系，一般称为键值对
序列类型由0……n整数作为数据的默认索引，而字典类型则是由用户自定义数据的索引
自定义索引只要是非可变数据类型即可，可以说，键是数据索引的一种拓展
字典是键值对的集合，键值对之间无序
2、表示与用法
通常采用一对大括号{}和dict()函数来创建字典，空大括号{}创建的是字典!不是集合，因为编程中字典更为常用
键值对用冒号：表示，键值对之间用逗号，分隔，
字典形式类似于这样：{<键1>：<值1>，<键2>：<值2>，<键3>：<值3>，……<键n>：<值n>}
用法：我们可以通过索引——键来获得值或修改值。比如字典d,d[<键>] = 要修改的值
3、操作函数和方法
| 函数或方法 | 描述 |
| del d[k] | 删除字典d中键k对应的数据值 |
| k in d | 判断键k是否在字典中，在返回True，不在返回False |
| d.keys() | 返回字典d的所有键信息 |
| d.values() | 返回字典d的所有值信息 |
| d.items() | 返回字典d的所有键值对的信息 |
| d.get(k,<default>) | 键k存在，则返回相应值，不在则返回<default>值 |
| d.pop(k,<default>) | 键k存在，则取出相应值，不在则返回<default>值 |
| d.popitem() | 随机从字典中取出一个键值对，返回值为元组类型 |
| d.clear() | 删除所有键值对 |
| len(d) | 返回字典d中键值对的个数 |
举个栗子：^_^
d = { "山西":"太原", "山东":"济南", "湖北":"武汉", "河南":"郑州", "浙江":"杭州", }#定义一个省份字典 print(d.get("福建","None"))# None，因为字典中无以'福建'为键的键值对，所以返回第二个参数即<default> print(d.popitem())# ('浙江', '杭州'),元组形式！！！
4、应用
数据表示
因为字典的键值对本质上就是映射，所以我们可以用字典来表示日常生活工作中需要用映射来表达的东西
比如：统计某个东西出现的次数，可以让这个东西作为键，次数作为值存一个字典
存储好之后，能通过自定义索引也就是键更好的操作他们
比如遍历for key in d:进行操作，等等
2046
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
