目录
python数据类型1:https://blog.csdn.net/sandalphon4869/article/details/88546235
一、集合类型
1.定义
集合类型：
（1）集合是多个元素的无序组合
（2）集合类型与数学中的集合概念一致
（3）集合元素之间无序，每个元素唯一，不存在相同元素
（4）集合元素不可更改，不能是可变数据类型（万一可变，就可能相同）
非可变数据类型：整数，浮点数，复数，字符串，元组类型
可变数据类型：列表
2.集合类型初始化
表示：
（1）集合用大括号{}表示，元素间用逗号分隔
（2）建立集合类型用{}或set()
（3）建立空集合类型，必须用set()
#{}表示
a={"123",13,True}
print(a)
#{'123', 13, True}
#set()表示
s=set("123")
print(s)
#{'1', '2', '3'}#set()试错
#一个元素用单引号
a=set('1')
print(a)
#{'1'}
#多个元素用单引号
b=set('123')
print(b)
#{'2', '3', '1'}
#多个元素间用逗号间隔
set('1','2','3')
#error
#多个元素
ls=["py123",123,True]
c=set(ls)
print(c)
#{'py123', 123, True}
"""
总结：set()中传入的参数是一个其他类型的变量，'1'和'123'都是字一个符串类型的量，'1','2','3'错是因为它是多个元素，
要传入特定的多个元素，就要像ls一样将它们包装到另一种类型中成为一个变量。
"""3.集合操作符
（1）基本操作符：
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={"p","y",123} #{'y', 123, 'p'}
B=set("pypy123") #{'1', 'y', '2', '3', 'p'}
print(A-B)
#{123}
print(B-A)
#{'3','1','2'}
print(A&B)
#{'p','y'}
print(A|B)
#{'1','p','2','y','3',123}
print(A^B)
#{'2','1','3',123}
（2）增强操作符：
S|=T ：更新集合S，包括在集合S和T中的所有元素
S-=T ：更新集合S，包括在集合S但不在T中的元素
S&=T ：更新集合S，包括同时在集合S和T中的元素
S^=T ：更新集合S，包括集合S和T中的非相同元素
3.集合的处理方法
S.add(x) ： 如果x不在集合S中，将x增加到S
S.discard(x) ：移除S中元素x，如果x不在集合S中，不报错
S.remove(x) ： 移除S中元素x，如果x不在集合S中，产生KeyError异常
S.clear() ： 移除S中所有元素
S.pop() ： 随机返回S的一个元素，同时在集合中移除这个元素并更新S，若S为空产生KeyError异常
S.copy() ： 返回集合S的一个副本
len(S) ： 返回集合S的元素个数
x in S ： 判断S中元素x，x在集合S中，返回True，否则返回False
x not in S ： 判断S中元素x，x不在集合S中，返回False，否则返回True（和上面一样，都是在则True）
set(x) ： 将其他类型变量x转变为集合类型4.集合类型应用场景
#数据去重：集合类型所有元素无重复
ls=["p","p","y","y",123]
s=set(ls) #利用集合无重复元素的特点
print(s)
#{'p','y',123}
lt=list(s) #将集合转换为列表
print(lt)
#['p','y',123]二、序列类型
1.序列类型定义
序列：
（1）序列是具有先后关系的一组元素
（2）序列是一维元素向量，元素类型可以不同
（3）序列类型是一种基类，衍生类型为：字符串类型、元组类型和列表类型
序列的序号：
就是那个正向递增序号和反向递减序号
2.序列处理函数及方法
6个操作符：
（1）x in s ：如果x是序列s的元素，返回True，否则返回False
（2）x not in s ：如果x是序列s的元素，返回True，否则返回False
（3）s+t ：连接两个序列s和t
（4）s*n或n*s ：将序列s复制n次
（5）s[i] ：索引，返回s中的第i个元素，i是序列的序号
（6）s[i:j]或s[i:j:k]：切片，返回序列s中第i到j以k为步长的元素子序列
5个函数和方法：
（1）len(s) ：返回序列s的长度
（2）nin(s) ：返回序列s的最小元素，s中元素需要可比较
（3）max(s) ：返回序列s的最大元素，s中元素需要可比较
（4）s.index(x)或s.index(x,i,j)：返回序列s从i开始到j位置中第一次出现元素x的位置
（5）s.count(x)：返回序列s中出现x的总次数
3,元组类型及操作
元组类型：
（1）元组是序列类型的一种扩展，一旦创建就不能被修改
（2）使用小括号()或tuple()创建，元素间用逗号，分隔
（3）可以使用或不使用小括号
#例1：
def func()
return 1,2
#这个1，2就是一种不使用小括号的元组类型#例2：
creature="cat","dog","tiger","human"
print(creature)
('cat','dog','tiger','human')
print(creature)
('cat', 'dog', 'tiger', 'human')
#不像集合，原元组未改变，序列类型有特定的顺序
color=(0x001100,"blue",creature)
print(color)
(4352,'blue',('cat','dog','tiger','human'))#例3：
creature="cat","dog","tiger","human"
print(creature[::-1])
#('human', 'tiger', 'dog', 'cat')
color=(0x001100,"blue",creature)
print(color[-1][2]) #[-1]是creature,[-2]是creature变量里的[2]tiger
#'tiger'4.列表类型及操作
（1）列表类型定义：
（1）列表是序列类型的一种扩展，创建后可以随意被修改
（2）使用方括号[]或list()创建，元素间用逗号，分隔
（3）可以使用或不使用小括号
#例1：
ls=["cat","dog","tiger",1024]
print(ls)
['cat', 'dog', 'tiger', 1024]
#方括号[]真正创建一个列表，赋值仅传递引用
lt=ls
print(lt)
#['cat', 'dog', 'tiger', 1024]
lt[0]="change"
print(lt)
#['change', 'dog', 'tiger', 1024]
print(ls)
#['change', 'dog', 'tiger', 1024]#嵌套序列(比如由一组等长列表组成的列表)
data=[[1,2,3],[4,5,6]]
print(data)
#[[1, 2, 3], [4, 5, 6]]（2）函数或方法：
（1）ls[i]=x： 替换列表ls第i元素为x
（2）ls[i:j:k]=lt： 用列表lt替换ls切片后所对应元素子列表
（3）del ls[i]： 删除列表ls中第i元素
（4）del ls[i:j:k]： 删除列表ls中第i到第j以k为步长的元素
（5）ls+=lt： 更新列表ls，将列表lt元素增加到列表ls中
（6）ls*=n： 更新列表ls，将元素重复n次
（7）ls.append(x)： 在列表ls最后增加一个元素x
（8）ls.clear()： 删除列表ls中所有元素
（9）ls.copy()： 生成一个新列表，赋值ls中所有元素
（10）ls.insert(i,x)： 在列表ls的第i位置增加元素x
（11）ls.pop(i)： 将列表ls中第i位置元素取出并删除该元素
（12）ls.remove(x)： 将列表ls中出现的第一个元素x删除
（13）ls.reverse()： 将列表ls中的元素反转#例2：
ls=["cat","dog","tiger",1024] #ls[0]='cat'
ls[1:2]=[1,2,3,4]
print(ls)
#['cat', 1, 2, 3, 4, 'tiger', 1024]
del ls[::3]
print(ls)
#[1,2,4,'tiger']#例3：
ls=["cat","dog","tiger",1024]
print(ls*2)
#['cat', 'dog', 'tiger', 1024,'cat', 'dog', 'tiger', 1024]#例4：
ls=["cat","dog","tiger",1024]
ls.append(1234)
print(ls)
#['cat', 'dog', 'tiger', 1024, 1234]
ls.insert(3,"human")
print(ls)
#['cat', 'dog', 'tiger', 'human', 1024, 1234]
ls.reverse()
print(ls)
#[1234, 1024, 'human', 'tiger', 'dog', 'cat']#例5：
#定义空列表lt
lt=[]
#向lt新增5个元素
lt+=[1,2,3,4,5]
#修改lt中第2个元素
lt[2]=6
#向lt中第2个位置增加一个元素
lt.insert(2,7)
#从lt中第1个位置删除一个元素
del lt[1]
#删除lt中第1-3位置元素
del lt[1:4]
#判断lt中是否包含数字0
print(0 in lt) #False
#向lt新增数字0
lt.append(0)
#print(lt) #[1, 5, 0]
#返回数字0所在lt中的索引
print(lt.index(0)) #2
#lt的长度
print(len(lt)) #3
#lt中最大元素
print(max(lt)) #5
#清空lt
lt.clear()5.序列类型的应用场景
应用场景：
（1）元组用于元素不改变的应用场景，更多用于固定搭配场景
（2）列表更加灵活，它是最常用的序列类型
（3）最主要的作用：表示一组有序数据，进而操作它们
数据保护：
-如果不希望数据被程序所改变，转换成元组类型
ls=["cat","dog","tiger",1024]
lt=tuple(ls)
print(lt)
#('cat', 'dog', 'tiger', 1024)三、字典类型
1.字典类型定义
理解映射：
-映射是一种键（索引）和值（数据）的对应
-序列类型有0...N整数作为数据的默认索引
字典类型：
（1）字典类型是映射的体现
（2）键值对：键是数据索引的扩展
（3）字典是键值对的集合，键值对之间无序
（4）采用大括号{}和dict()创建，键值对用冒号:表示
（5）
格式：
<字典变量>={<键1>:<值1>,<键2>:<值2>}
<值>=<字典变量>[<键>]
<字典变量>[<键>]=<值>
#[]用来向字典变量中索引或增加元素d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d)
#{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
print(d["中国"])
#'北京'
de={};
print(type(de)) #生成一个空的字典，type(x)返回变量x的类型
#<class 'dict'>2.字典处理函数及方法
函数或方法；
（1）del d[k]：删除字典d中键k对应的数据值
（2）k in d：判断键k是否在字典d中，如何在返回True，否则返回False
（3）d.keys()：返回字典d中所有的键信息
（4）d.values()：返回字典d中所有的值信息
（5）d.item()：返回字典d中所有键值对信息
（6）d.get(k,<default>)：键k存在，则返回相应值，不在则返回<default>值
（7）d.pop(k,<default>)：键k存在，则取出相应值，不在则返回<default>值
（8）d.popitem()：随机从字典d中取出一个 键值对，以元组形式返回
（9）d.clear()：删除所有的键值对
（10）len(d)：返回字典d中元素的个数d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print("中国"in d)
#True
print(d.keys())
#dict_keys(['中国', '美国', '法国']) #可以for遍历
print(d.values())
#dict_values(['北京', '华盛顿', '巴黎'])
print(d.get("中国","伊斯兰堡"))
'北京'
print(d.get("巴基斯坦","伊斯兰堡"))
'伊斯兰堡'
print(d.popitem())
('法国', '巴黎')#定义一个空字典d
d={}
#向d新增2个键值对元素
d["a"]=1;d["b"]=2
#修改b键的值(字典中并没有先后顺序)
d["b"]=3
print(d.keys())
#dict_keys(['a', 'b'])
print(d.values())
#dict_values([1, 3])
#判断字符"c"是否是d的键
print("c" in d) #False
#计算d的长度
print(len(d)) #2
#清空d
d.clear()