组合数据类型

1 集合类型

（1）无序集合定义

* 多个元素的无序组合
* 元素之间无序，每个元素唯一，不存在相同元素
* 集合元素不能是可变的数据类型，可以为整数，复数，浮点数，字符串，元组等


* 建立集合类型用 a={...} 或 a=set(...)
* 建立空集，必须用a=set{ }，因为a={ }被定义为创建字典
* 元素间用逗号隔开

（2）集合间操作

S | T   					并  S+T 
S - T						差  S-T
S & T						交  同时在S和T中的元素
S ^ T						补  包含S和TZ中的非相同元素
S <= T	or S < T		返回True或False，判断S和T的子集关系
S >= T or S > T			返回True或False，判断S和T的包含关系

增加操作符：
s|=t	s-=t	s&=t	s^=t

（3）集合处理方法

增加：	s.add(x) 		如果x不在s中，将x加入其中，注意，集合内的元素是不能重复的；无返回值，直接更新s

移除：	s.discard(x)	移除s中的x，若无x，不报错；无返回值
移除： 	s.remove(x)		移除s中的x，若无x，产生异常；无返回值

清除：	s.clear()		移除所有元素；无返回值
取出：	s.pop()			在s中随机取出一个元素，并更新s；有返回值

复制：	s.copy()		返回s的一个副本
个数：	len(s)			返回s中元素个数

布尔值	x in set 		返回True或False	
布尔值	x not in s 		返回True或False	

转换	set(a)			将其他类型变量转为集合类型，多用于数据去重

2 序列类型

（具有先后关系的一组元素，如：字符串、元组、列表）

（1）基本处理方法

x in s		s+t		len(s)		max(s) | min(s)

s.count(x)			s中x出现次数

s*n | n*s 			n个s，n为整数类型

s[i] | s[i,j,k]		索引、切片，k为步长

s.index(x)			s中第一次出现x的位置
s.index(x,i,j)		s中，i-j位置第一次出现x的位置

（2）元组

--1 一旦创建就不能更改（指的是程序互相调用的时候不能更改其内部的元素）
--2 使用a=（）或a=tuple（）创建，元素间用‘，’逗号隔开
--3 可以不使用（），例：a=1，2，3 一样是元组类型

（3）列表

创建后可随意更改

用a=[]或a=list()创建
如果只是将列表进行赋值的话，没有真正的创建一个列表，只是给列表加了一个名字罢了

例：
ls=['a','b','c']
it=ls
it.append('d')
print(it,ls)		得到的结果是['a', 'b', 'c', 'd'] ['a', 'b', 'c', 'd']

• 对列表进行操作（操作符）

ls[i]=x			替换列表的i号元素为x
ls[i:j:k]=it	用it替换ls切片后所对应的元素，it可为列表、元组、集合、字符串等

del ls[i]		删除列表的i号元素； del 为保留字
del	ls[i:j:k]

ls+=it			将it加到ls后，可一次加多个元素，it可为列表、元组、集合、字符串等
ls*=n			列表内的元素重复n次

• 用函数操作列表

ls.append(x)	在ls最后添加x(无论什么类型，只加一个)

例：
ls=[1,2,3]
ls.append(['a','b'])	  得 [1, 2, 3, ['a', 'b']]


ls.clear()		清空列表ls
a=ls.copy()		生成一个新的列表

ls.insert(i,x)	列表ls的第i位置加入x
a=ls.pop(i)		将列表第i号元素取出，且不放回列表内
ls.remove(x)	将列表内第一次出现的x删除

ls.reverse()	将列表元素翻转，没有返回值
it=list(reversed(ls))	翻转，有返回值

• 扩展

li=[456,123,789]
b=sorted(li,reverse=True)       不加reverse=True的话默认按从小到大排序    
print(b)

[789, 456, 123]


d=[ ('a',123), ('b',456), ('c',789) ]
d.sort(key=lambda x: x[1],reverse=True)     lambda 创建的函数意味着排序的时候，选取每一个元素内的第二个元素作为参考
print(d)

[('c', 789), ('b', 456), ('a', 123)]

3 映射类型

一种键（索引）和值（元素）的对应---字典
字典用{} 和dict（）创建
它是无序的

例：
d={'中国':'北京', '法国':'巴黎'}
d['中国'] 	得 '北京'

修改或者增加元素
d[键]=值	|	值=d[键]

• 操作字典的函数

del [k]			删除键k及其对应数据值

k in d 			判断k键是否在d中，返回True或False


d.keys()		返回d中所有键信息，返回的类型是字典的key类型
d.values()		返回d中所有值信息，返回的类型是字典的value类型
d.items()		返回d中所有键值信息，返回的类型是字典的items类型

上述类型可用for in 作遍历

例：
for k,v in d.items():		迭代输出字典内的键和值
    print(k,v)

• 操作字典的方法

d.get(k,<default>)		键k存在，返回其对应的值；不存在则返回<default>值

d.pop(k,<default>)		取出键k，返回其对应的值；不存在则返回<default>值；不放回
d.popitem()				随机取出一个键值对，并以元组形式返回；不放回

d.claer()				清除所有
len(d)					返回长度

• 扩展（有序字典）

import collections      导入collections库
d={}
d=collections.OrderedDict()
d['a']=1
d['b']=2
d['c']=3
for k,v in d.items():
    print(k,v)

按输入的顺序进行输出
a 1
b 2
c 3

注意，其有顺序的前提是其有一个插入元素的过程
如果一开始字典内已有定义好的元素，则后续的输出不会将其输出，只会将按照此方法进行插入的元素进行输出
如果只是像下面一样，没有进行输入，则最后的输出为空
d={'中国':'北京', '法国':'巴黎'}
d=collections.OrderedDict()
for k,v in d.items():
    print(k,v)