Python-组合数据类型及其操作（集合，序列，字典）

zip(a,b) 将两个可迭代对象变为新的匹配的可迭代对象，元素为元组，如果长度不匹配，按最小长度输出，用dict(),list()等转化为对应类型

Python中组合数据类型包括：

组合数据类型包括集合类型，序列类型和字典类型。

集合类型

集合类型：多个元素的无序组合，元素唯一（不存在相同元素），元素必须是不可变元素类型，比如整数
    创建：集合用大括号表示，元素之间用逗号分隔，建立集合用{}或set{}，空集合不可以直接用{}建立

集合操作符

创建：集合用大括号表示，元素之间用逗号分隔，建立集合用{}或set{}
集合操作符：
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 包含关系，返回True或False

集合操作函数及方法

集合处理方法
s.add() 增加元素
s.discard() 移除元素，若元素不在集合中不会报错
s.remove() 移除元素，若元素不在集合中产生keyerror异常
s.clear() 移除所有元素
s.pop() 随机取出一个元素并删除该元素
s.copy 复制(全切片效果相同)
len(s) 返回元素个数
x in s 判断x是否在集合中
x not in s 反之
set(s) 转化为集合类型

A = {1,4,3,5,3}
print(A)
A.add(6)
#增加6
print(A)
A.remove(6)
#移除6
print(A)
B = {3,5,7,6,8}
print(A|B)
#并
print(A-B)
#差
print(A&B)
#交
print(A^B)
#补

{1, 3, 4, 5}
{1, 3, 4, 5, 6}
{1, 3, 4, 5}
{1, 4, 6, 7, 8}
{1, 3, 4, 5, 6, 7, 8}
{1, 4}
{3, 5}

循环遍历集合

循环遍历集合
for in 形式：输出顺序不同（集合内部有自己的顺序）
    A=set()
    for item in A:
        print(item,end="")
while 形式：
    A=set()
    try:
        while True:
            print(A.POP().end="")
    except:
            pass

例子：

s = {"2","您","早上好","晚上好","2"}
# 元素唯一，无序
for item in s:
    print(item,end=",")
print("\n")

while s:
    print(s.pop(),end=",")
print("\n")

2,您,早上好,晚上好,

2,您,早上好,晚上好,

序列类型

序列类型：包括字符串，元组，列表

序列通用操作符

序列类型通用操作符：
    x in s:如果x是s的元素，返回True，否则返回False
    x not in s:反之
    s + t:连接两个序列
    s*n 或 n*s:将序列s复制n次
    s[i]:索引，返回第i个元素
    s[i:j:k]:切片，返回s中第i到j(不算)以k为步长的元素子序列
        s[::-1]:倒序输出

序列类型函数与方法

函数和方法：
    len(s)：返回长度
    min(s):返回最小
    max(s):返回最大元素，可比较
    s.index(x,i,j):返回s中从i到j中第一次出现x的位置

字符串类型

字符串有两类四种表示方法：
单引号，双引号表示单行
三单引号，三双引号表示多行

字符串操作符与转义符

特殊字符 转义符\
    表达特定字符的本意
    转义符形成一些组合，表达一些不可打印的含义
        \b 回退
        \n 换行
        \r 回到行首
字符串操作符
    x + y 字符串连接
    n*x 复制
    x in y 如果x是y的子串，返回True,否则返回Flase
    索引：返回字符串中单个字符 <字符串>[m] 
    切片：返回多个字符 <>[M:N],M确实表示至开头，N缺失表示至结尾 <>[M:N:K],根据步长K对字符串切片 倒序排列 <>[::-1],-1表示从后向前提取字符

字符串操作函数与方法

字符串处理函数
    len(x),返回字符串长度
    str(x),将任意类型X转换成字符串形式
    eval(x),将字符串形式的数字最外侧的双引号除去，变为数字
    hex(x)或 oct(x),整数x的16进制和8进制小写形式字符串
    chr(u)u为unicode编码，返回对应字符
    ord(x),x为字符，返回对应unicode编码
字符串处理方法
    str.lower或str.upper,返回副本，全部字符大写或小写
    str.split(sep)，返回一个列表，被sep部分分割
    str.count(sub),返回字串sub在字符串中出现的次数
    str.replace(old,new),返回副本，所有old子串被替换为new子串
    str.center(width[,fillchar])字符串str根据宽度居中，fillchar可选，为填充字符
        "python".center(20,"=")
    str.strip(chars) 从str中去掉在其左侧和右侧chars中列出的字符
        "= python=".strip("=np"）结果为"ytho"
    str.join(iter) 在iter变量除最后元素外每个元素后增加一个str
        ",".join(“12345"）结果为"1,2,3,4,5”主要用于字符串分隔等

e = "1234567896789abcde"
print(e.upper())
print(e.split('9'))
print(e.count('8'))
print(e.replace('1','z'))
print(e.strip('1e2'))
print(','.join(e))
print(e.center(30,"*"))

1234567896789ABCDE
['12345678', '678', 'abcde']
2
z234567896789abcde
34567896789abcd
1,2,3,4,5,6,7,8,9,6,7,8,9,a,b,c,d,e
******1234567896789abcde******

字符串格式化

字符串格式化
    <{:.2f}>.format(<逗号分隔的参数>)
    槽：起到占位的作用{},如果要改变参数格式，加上:再填写控制标记
    格式控制标记:严格遵守顺序{<参数序列>:<格式控制标记>}
        填充
        对齐
        宽度
            "{:=^20}".format("PYTHON")
        ,   数字的千位分隔符
        .精度
        类型
            整数类型：
                b 二进制整数
                d 十进制整数
                o 八进制整数
                x 十六进制整数
            浮点数类型：
                e 指数（基底为e）
                E 指数（基底为E）
                f 浮点数
                % 百分号
            字符串类型
                s 字符串
                c 单个字符，也可将unicode转换输出字符，chr

print("{:=^20,.4f}".format(1234.56789))

=====1,234.5679=====

元组类型

元组:元组一旦创建不可修改
    创建：使用小括号()或tuple()创建，元素间用逗号隔开，可以使用或不使用小括号
    继承序列类型全部操作

例子：

human ="男","女"
print(type(human))
#元组类型
print(human[::-1])
#倒序输出

<class 'tuple'>
('女', '男')

列表类型

列表：可以被随意更改
    创建：使用方括号[]或list()创建，元素用逗号分隔，元素类型无限制，无长度限制

列表类型操作符

ls[i]=x 将元素x赋值给ls第i个元素
ls[i:j:k] = lt 用列表lt替换ls切片后对应元素子列表
del ls[i] 删除列表ls中第i元素
del ls[i:j:k] 删除列表中第i到第j步长为k的元素
ls+=lt 更新列表，使得lt加入ls中
ls*=n ls重复n次

列表类型函数与方法

ls.append[] 添加
ls.extend() 将一个可迭代对象中的所有元素添加至列表中
ls.clear() 清空
ls.copy() 复制()
ls.insert(i,x) 插入元素
ls.pop(i) 去除并删除元素
ls.remove(x) 将列表中出现的第一个x删除
ls.reverse() 将列表反转(ls[::-1]效果一致)
ls.sort(key=None),reverse=False)) 对列表的元素进行就地排序,key为函数，reverse后false为升 序，true为倒序(改变原始序列)
sorted(ls,*,key=None,reverse=False) 排序函数，返回新的列表，不改变原始列表
s.join(ls)  函数join()用于将一个列表的各个字符串类型的元素组合成一个字符串，元素之间用指定的内容s填充。

ls = [1,3,2,4,5]
ls.sort(reverse=True)
print(ls)
print(sorted(ls,reverse=False))
print(ls)

[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

列表解析式

列表解析式：快速创建列表
    [元素描述 for 迭代元素 in 可迭代数据类型 if 判断语句]  从循环中提取符合需求的元素进入列表

lt = [x for x in range(1,101) if x%3==0]
print(lt)
# 通过列表解析式获得从1到100中能被3整除的数构成的列表
lt= [(x,y) for x in [1,2] for y in [3,4]]
print(lt)
# 嵌套循环

[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]
[(1, 3), (1, 4), (2, 3), (2, 4)]

字典类型

字典类型：映射是一种键（索引）和值（数据）的对应关系，将默认的索引变为用户定义的索引
    字典是键值对的集合，键值对之间无序，采用大括号{}或dict()创建，键值对用冒号:表示.
    空大括号是字典类型，不是集合类型
    字典变量中，通过键获得值
    d[<键>]=<值>

操作方法与函数

操作函数和方法：
    del d[k] 删除字典d中键k对应的数据
    k in d 判断键k是否在d中
    d.keys() 返回字典中所有键的信息（keys类型）
    d.values() 返回字典d中所有的值信息（values类型）
    d.items() 返回字典中所有的键值对信息
    方法：
    d.get(k,<default>) 键k存在，返回相应值，不存在返回默认值
    d.pop(k,<default>) 键k存在，取出相应值（删除），不存在返回默认值
    d.popitem() 随机从字典中取出一个键值对，以元组形式
    d.clear() 清空字典
    len(d) 返回字典中元素格个数
    d1.update(d2) 合并：将d2加入至d1中
    d1|d2 合并两个字典
    zip(a,b) 将两个可迭代对象变为新的匹配的可迭代对象，元素为元组，如果长度不匹配，按最小长度输出，用dict(),list()等转化为对应类型

d={1:"您",2:"好",3:"啊"}
#创建字典
print(d[1])
print(d.get(2,34))
print(d.get(4,"不存在哦"))

您
好
不存在哦

d={1:"您",2:"好",3:"啊"}
print(d)
print(type(d))
#字典类型
print(d.keys())
print(type(d.keys()))
#d.keys()返回的是keys类型
print(d.values())
print(type(d.values()))
#d.values()返回的是values类型
print(d.items())
print(type(d.items()))
#d.items()返回的是items类型

{1: '您', 2: '好', 3: '啊'}
<class 'dict'>
dict_keys([1, 2, 3])
<class 'dict_keys'>
dict_values(['您', '好', '啊'])
<class 'dict_values'>
dict_items([(1, '您'), (2, '好'), (3, '啊')])
<class 'dict_items'>

遍历字典

遍历字典
    for key,value in a:
        print(key,":",value)       a为字典，key和value分别提取键和值z

字典解析式

{键：值 循环 判定}

例如{x:x*x for i in[1,3,5]}

例子：

a = {x:x*x for x in range(10) if x%3 == 0}
print(a)

{0: 0, 3: 9, 6: 36, 9: 81}